From 4d9960d479ddabb77c6cd458c8625c1fdd5799aa Mon Sep 17 00:00:00 2001
From: Daniel Duan <daniel@duan.ca>
Date: Thu, 9 Jul 2026 01:30:45 -0700
Subject: [PATCH 1/4] Pin SwiftFormat

---
 Package.swift | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Package.swift b/Package.swift
index 25bd292d..07cf35d7 100644
--- a/Package.swift
+++ b/Package.swift
@@ -24,7 +24,7 @@ var docsDeps: [Package.Dependency] = includeDocs ? [
 ] : []
 
 var formattingDeps: [Package.Dependency] = includeFormatting ? [
-    .package(url: "https://github.com/nicklockwood/SwiftFormat", from: "0.58.6"),
+    .package(url: "https://github.com/nicklockwood/SwiftFormat", exact: "0.62.1"),
 ] : []
 
 var targets: [Target] = [

From 7de363133c62ffaa87f966a5af8567b8a035a020 Mon Sep 17 00:00:00 2001
From: Daniel Duan <daniel@duan.ca>
Date: Thu, 9 Jul 2026 01:33:08 -0700
Subject: [PATCH 2/4] Format with pinned SwiftFormat

---
 Sources/TOMLDecoder/DateTime.swift            |    4 +-
 .../TOMLDecoderTests/DateStrategyTests.swift  |   29 +-
 .../DateTimeDescriptionTests.swift            |   19 +-
 .../DateTimeExactMatchTests.swift             |   13 +-
 .../InvalidationTests.Generated.swift         | 1865 ++++++++---------
 .../LeafValueDecodingTests.Generated.swift    |   29 +-
 Tests/TOMLDecoderTests/TOMLDecoderTests.swift |   33 +-
 .../TOMLTableKeyMembershipTests.swift         |    5 +-
 .../ValidationTests.Generated.swift           |  853 ++++----
 9 files changed, 1422 insertions(+), 1428 deletions(-)

diff --git a/Sources/TOMLDecoder/DateTime.swift b/Sources/TOMLDecoder/DateTime.swift
index e38b5daa..e42398af 100644
--- a/Sources/TOMLDecoder/DateTime.swift
+++ b/Sources/TOMLDecoder/DateTime.swift
@@ -134,7 +134,9 @@ public struct OffsetDateTime: Equatable, Hashable, Sendable, Codable, CustomStri
         let offsetInSeconds = Int64(offset) * 60
 
         var y = year
-        if month <= 2 { y -= 1 }
+        if month <= 2 {
+            y -= 1
+        }
 
         let era = (y >= 0 ? y : y - 399) / 400
         let yoe = y - era * 400
diff --git a/Tests/TOMLDecoderTests/DateStrategyTests.swift b/Tests/TOMLDecoderTests/DateStrategyTests.swift
index 4eb475ce..44752079 100644
--- a/Tests/TOMLDecoderTests/DateStrategyTests.swift
+++ b/Tests/TOMLDecoderTests/DateStrategyTests.swift
@@ -2,10 +2,9 @@ import Foundation
 import Testing
 @testable import TOMLDecoder
 
-@Suite
 struct DateStrategyTests {
     @Test(.tags(.datetime))
-    func datetimeAsDateByKey() throws {
+    func `datetime as date by key`() throws {
         struct Test: Decodable {
             let datetime: OffsetDateTime
         }
@@ -26,7 +25,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func datetimeAsDate() throws {
+    func `datetime as date`() throws {
         struct Test: Decodable {
             let datetime: Date
         }
@@ -42,7 +41,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func datetimeAsTimeIntervalSince1970() throws {
+    func `datetime as time interval since 1970`() throws {
         struct Test: Decodable {
             let datetime: TimeInterval
         }
@@ -58,7 +57,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func datetimeAsTimeIntervalSince2001() throws {
+    func `datetime as time interval since 2001`() throws {
         struct Test: Decodable {
             let datetime: TimeInterval
         }
@@ -74,7 +73,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func datetimeAsProlepticGregorianDate() throws {
+    func `datetime as proleptic gregorian date`() throws {
         struct Test: Decodable {
             let datetime: Date
         }
@@ -90,7 +89,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func datetimeAsCustomCalendar() throws {
+    func `datetime as custom calendar`() throws {
         struct Test: Decodable {
             let datetime: Date
         }
@@ -106,7 +105,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func datetimeWithStrictStrategy() throws {
+    func `datetime with strict strategy`() throws {
         struct Test: Decodable {
             let datetime: Date
         }
@@ -124,7 +123,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func datetimeAsOffsetDateTimeInArray() throws {
+    func `datetime as offset date time in array`() throws {
         struct Test: Decodable {
             let datetimes: [OffsetDateTime]
         }
@@ -145,7 +144,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func datetimeAsDateInArray() throws {
+    func `datetime as date in array`() throws {
         struct Test: Decodable {
             let datetimes: [Date]
         }
@@ -161,7 +160,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func datetimeAsTimeIntervalSince1970InArray() throws {
+    func `datetime as time interval since 1970 in array`() throws {
         struct Test: Decodable {
             let datetimes: [TimeInterval]
         }
@@ -177,7 +176,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func datetimeAsTimeIntervalSince2001InArray() throws {
+    func `datetime as time interval since 2001 in array`() throws {
         struct Test: Decodable {
             let datetimes: [TimeInterval]
         }
@@ -193,7 +192,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func datetimeAsProlepticGregorianDateInArray() throws {
+    func `datetime as proleptic gregorian date in array`() throws {
         struct Test: Decodable {
             let datetimes: [Date]
         }
@@ -209,7 +208,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func datetimeAsCustomCalendarInArray() throws {
+    func `datetime as custom calendar in array`() throws {
         struct Test: Decodable {
             let datetimes: [Date]
         }
@@ -225,7 +224,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func datetimeWithStrictStrategyInArray() throws {
+    func `datetime with strict strategy in array`() throws {
         struct Test: Decodable {
             let datetimes: [Date]
         }
diff --git a/Tests/TOMLDecoderTests/DateTimeDescriptionTests.swift b/Tests/TOMLDecoderTests/DateTimeDescriptionTests.swift
index d45e4fba..841fce82 100644
--- a/Tests/TOMLDecoderTests/DateTimeDescriptionTests.swift
+++ b/Tests/TOMLDecoderTests/DateTimeDescriptionTests.swift
@@ -1,10 +1,9 @@
 import Testing
 @testable import TOMLDecoder
 
-@Suite
 struct DateTimeDescriptionTests {
     @Test(.tags(.local_date))
-    func localDateBasicFormatting() {
+    func `local date basic formatting`() {
         let date = LocalDate(year: 2023, month: 5, day: 27)
         #expect(date.description == "2023-05-27")
 
@@ -13,7 +12,7 @@ struct DateTimeDescriptionTests {
     }
 
     @Test(.tags(.local_time))
-    func localTimeWithoutFractionalSeconds() {
+    func `local time without fractional seconds`() {
         let time = LocalTime(hour: 7, minute: 32, second: 0, nanosecond: 0)
         #expect(time.description == "07:32:00")
 
@@ -22,7 +21,7 @@ struct DateTimeDescriptionTests {
     }
 
     @Test(.tags(.local_time))
-    func localTimeWithFractionalSeconds() {
+    func `local time with fractional seconds`() {
         let timeWithMicroseconds = LocalTime(hour: 7, minute: 32, second: 0, nanosecond: 999_000_000)
         #expect(timeWithMicroseconds.description == "07:32:00.999")
 
@@ -37,7 +36,7 @@ struct DateTimeDescriptionTests {
     }
 
     @Test(.tags(.local_datetime))
-    func localDateTimeBasicFormatting() {
+    func `local date time basic formatting`() {
         let date = LocalDate(year: 1979, month: 5, day: 27)
         let time = LocalTime(hour: 7, minute: 32, second: 0, nanosecond: 0)
         let dateTime = LocalDateTime(date: date, time: time)
@@ -49,7 +48,7 @@ struct DateTimeDescriptionTests {
     }
 
     @Test(.tags(.datetime))
-    func offsetDateTimeZSuffixFormatting() {
+    func `offset date time Z suffix formatting`() {
         let date = LocalDate(year: 1979, month: 5, day: 27)
         let time = LocalTime(hour: 7, minute: 32, second: 0, nanosecond: 0)
         let uppercaseZ = OffsetDateTime(date: date, time: time, offset: 0, features: [.uppercaseZ])
@@ -60,7 +59,7 @@ struct DateTimeDescriptionTests {
     }
 
     @Test(.tags(.datetime))
-    func offsetDateTimeNumericOffsetFormatting() {
+    func `offset date time numeric offset formatting`() {
         let date = LocalDate(year: 1979, month: 5, day: 27)
         let time = LocalTime(hour: 0, minute: 32, second: 0, nanosecond: 0)
 
@@ -75,7 +74,7 @@ struct DateTimeDescriptionTests {
     }
 
     @Test(.tags(.datetime))
-    func offsetDateTimeLowercaseTSeparator() {
+    func `offset date time lowercase T separator`() {
         let date = LocalDate(year: 1979, month: 5, day: 27)
         let time = LocalTime(hour: 7, minute: 32, second: 0, nanosecond: 0)
 
@@ -87,7 +86,7 @@ struct DateTimeDescriptionTests {
     }
 
     @Test(.tags(.datetime))
-    func offsetDateTimeWithFractionalSeconds() {
+    func `offset date time with fractional seconds`() {
         let date = LocalDate(year: 1979, month: 5, day: 27)
         let timeWithFraction = LocalTime(hour: 0, minute: 32, second: 0, nanosecond: 999_999_000)
 
@@ -96,7 +95,7 @@ struct DateTimeDescriptionTests {
     }
 
     @Test(.tags(.datetime))
-    func offsetDateTimeValidationWithZFlags() {
+    func `offset date time validation with Z flags`() {
         let date = LocalDate(year: 1979, month: 5, day: 27)
         let time = LocalTime(hour: 7, minute: 32, second: 0, nanosecond: 0)
 
diff --git a/Tests/TOMLDecoderTests/DateTimeExactMatchTests.swift b/Tests/TOMLDecoderTests/DateTimeExactMatchTests.swift
index 39fb1c19..75decd60 100644
--- a/Tests/TOMLDecoderTests/DateTimeExactMatchTests.swift
+++ b/Tests/TOMLDecoderTests/DateTimeExactMatchTests.swift
@@ -1,10 +1,9 @@
 import Testing
 import TOMLDecoder
 
-@Suite
 struct DateTimeExactMatchTests {
     @Test(.tags(.local_date))
-    func localDateExactMatch() throws {
+    func `local date exact match`() throws {
         let toml = """
         date = 2021-01-01
         date_with_time = 2021-01-01T01:02:03
@@ -22,7 +21,7 @@ struct DateTimeExactMatchTests {
     }
 
     @Test(.tags(.local_time))
-    func localTimeExactMatch() throws {
+    func `local time exact match`() throws {
         let toml = """
         time = 01:02:03
         time_with_date = 2021-01-01T01:02:03
@@ -40,7 +39,7 @@ struct DateTimeExactMatchTests {
     }
 
     @Test(.tags(.local_datetime))
-    func localDatetimeExactMatch() throws {
+    func `local datetime exact match`() throws {
         let toml = """
         datetime = 2021-01-01T01:02:03
         datetime_with_offset = 2021-01-01T01:02:03+01:00
@@ -56,7 +55,7 @@ struct DateTimeExactMatchTests {
     }
 
     @Test(.tags(.local_date, .array))
-    func localDateExactMatchInArray() throws {
+    func `local date exact match in array`() throws {
         let toml = """
         dates = [2021-01-01, 2021-01-01T01:02:03, 2021-01-01T01:02:03+01:00]
         """
@@ -73,7 +72,7 @@ struct DateTimeExactMatchTests {
     }
 
     @Test(.tags(.local_time, .array))
-    func localTimeExactMatchInArray() throws {
+    func `local time exact match in array`() throws {
         let toml = """
         times = [01:02:03, 2021-01-01T01:02:03, 2021-01-01T01:02:03+01:00]
         """
@@ -90,7 +89,7 @@ struct DateTimeExactMatchTests {
     }
 
     @Test(.tags(.local_datetime, .array))
-    func localDatetimeExactMatchInArray() throws {
+    func `local datetime exact match in array`() throws {
         let toml = """
         datetimes = [2021-01-01T01:02:03, 2021-01-01T01:02:03+01:00]
         """
diff --git a/Tests/TOMLDecoderTests/InvalidationTests.Generated.swift b/Tests/TOMLDecoderTests/InvalidationTests.Generated.swift
index 2705b370..77c773db 100644
--- a/Tests/TOMLDecoderTests/InvalidationTests.Generated.swift
+++ b/Tests/TOMLDecoderTests/InvalidationTests.Generated.swift
@@ -5,7 +5,6 @@ import Foundation
 import Testing
 import TOMLDecoder
 
-@Suite
 struct TOMLInvalidationTests {
     private var directoryURL: URL {
         URL(fileURLWithPath: #filePath)
@@ -19,2333 +18,2333 @@ struct TOMLInvalidationTests {
         try TOMLComplianceSupport.verifyInvalidFixture(tomlURL: tomlURL, sourceLocation: sourceLocation)
     }
 
-    @Test("[array] double comma 01", .tags(.array))
-    func array__double_comma_01() throws {
+    @Test(.tags(.array))
+    func `[array] double comma 01`() throws {
         try invalidate(pathComponents: ["array", "double-comma-01"])
     }
 
-    @Test("[array] double comma 02", .tags(.array))
-    func array__double_comma_02() throws {
+    @Test(.tags(.array))
+    func `[array] double comma 02`() throws {
         try invalidate(pathComponents: ["array", "double-comma-02"])
     }
 
-    @Test("[array] extend defined aot", .tags(.array))
-    func array__extend_defined_aot() throws {
+    @Test(.tags(.array))
+    func `[array] extend defined aot`() throws {
         try invalidate(pathComponents: ["array", "extend-defined-aot"])
     }
 
-    @Test("[array] extending table", .tags(.array))
-    func array__extending_table() throws {
+    @Test(.tags(.array))
+    func `[array] extending table`() throws {
         try invalidate(pathComponents: ["array", "extending-table"])
     }
 
-    @Test("[array] missing separator 01", .tags(.array))
-    func array__missing_separator_01() throws {
+    @Test(.tags(.array))
+    func `[array] missing separator 01`() throws {
         try invalidate(pathComponents: ["array", "missing-separator-01"])
     }
 
-    @Test("[array] missing separator 02", .tags(.array))
-    func array__missing_separator_02() throws {
+    @Test(.tags(.array))
+    func `[array] missing separator 02`() throws {
         try invalidate(pathComponents: ["array", "missing-separator-02"])
     }
 
-    @Test("[array] no close 01", .tags(.array))
-    func array__no_close_01() throws {
+    @Test(.tags(.array))
+    func `[array] no close 01`() throws {
         try invalidate(pathComponents: ["array", "no-close-01"])
     }
 
-    @Test("[array] no close 02", .tags(.array))
-    func array__no_close_02() throws {
+    @Test(.tags(.array))
+    func `[array] no close 02`() throws {
         try invalidate(pathComponents: ["array", "no-close-02"])
     }
 
-    @Test("[array] no close 03", .tags(.array))
-    func array__no_close_03() throws {
+    @Test(.tags(.array))
+    func `[array] no close 03`() throws {
         try invalidate(pathComponents: ["array", "no-close-03"])
     }
 
-    @Test("[array] no close 04", .tags(.array))
-    func array__no_close_04() throws {
+    @Test(.tags(.array))
+    func `[array] no close 04`() throws {
         try invalidate(pathComponents: ["array", "no-close-04"])
     }
 
-    @Test("[array] no close 05", .tags(.array))
-    func array__no_close_05() throws {
+    @Test(.tags(.array))
+    func `[array] no close 05`() throws {
         try invalidate(pathComponents: ["array", "no-close-05"])
     }
 
-    @Test("[array] no close 06", .tags(.array))
-    func array__no_close_06() throws {
+    @Test(.tags(.array))
+    func `[array] no close 06`() throws {
         try invalidate(pathComponents: ["array", "no-close-06"])
     }
 
-    @Test("[array] no close 07", .tags(.array))
-    func array__no_close_07() throws {
+    @Test(.tags(.array))
+    func `[array] no close 07`() throws {
         try invalidate(pathComponents: ["array", "no-close-07"])
     }
 
-    @Test("[array] no close 08", .tags(.array))
-    func array__no_close_08() throws {
+    @Test(.tags(.array))
+    func `[array] no close 08`() throws {
         try invalidate(pathComponents: ["array", "no-close-08"])
     }
 
-    @Test("[array] no close table 01", .tags(.array))
-    func array__no_close_table_01() throws {
+    @Test(.tags(.array))
+    func `[array] no close table 01`() throws {
         try invalidate(pathComponents: ["array", "no-close-table-01"])
     }
 
-    @Test("[array] no close table 02", .tags(.array))
-    func array__no_close_table_02() throws {
+    @Test(.tags(.array))
+    func `[array] no close table 02`() throws {
         try invalidate(pathComponents: ["array", "no-close-table-02"])
     }
 
-    @Test("[array] no comma 01", .tags(.array))
-    func array__no_comma_01() throws {
+    @Test(.tags(.array))
+    func `[array] no comma 01`() throws {
         try invalidate(pathComponents: ["array", "no-comma-01"])
     }
 
-    @Test("[array] no comma 02", .tags(.array))
-    func array__no_comma_02() throws {
+    @Test(.tags(.array))
+    func `[array] no comma 02`() throws {
         try invalidate(pathComponents: ["array", "no-comma-02"])
     }
 
-    @Test("[array] no comma 03", .tags(.array))
-    func array__no_comma_03() throws {
+    @Test(.tags(.array))
+    func `[array] no comma 03`() throws {
         try invalidate(pathComponents: ["array", "no-comma-03"])
     }
 
-    @Test("[array] only comma 01", .tags(.array))
-    func array__only_comma_01() throws {
+    @Test(.tags(.array))
+    func `[array] only comma 01`() throws {
         try invalidate(pathComponents: ["array", "only-comma-01"])
     }
 
-    @Test("[array] only comma 02", .tags(.array))
-    func array__only_comma_02() throws {
+    @Test(.tags(.array))
+    func `[array] only comma 02`() throws {
         try invalidate(pathComponents: ["array", "only-comma-02"])
     }
 
-    @Test("[array] tables 01", .tags(.array))
-    func array__tables_01() throws {
+    @Test(.tags(.array))
+    func `[array] tables 01`() throws {
         try invalidate(pathComponents: ["array", "tables-01"])
     }
 
-    @Test("[array] tables 02", .tags(.array))
-    func array__tables_02() throws {
+    @Test(.tags(.array))
+    func `[array] tables 02`() throws {
         try invalidate(pathComponents: ["array", "tables-02"])
     }
 
-    @Test("[array] text after array entries", .tags(.array))
-    func array__text_after_array_entries() throws {
+    @Test(.tags(.array))
+    func `[array] text after array entries`() throws {
         try invalidate(pathComponents: ["array", "text-after-array-entries"])
     }
 
-    @Test("[array] text before array separator", .tags(.array))
-    func array__text_before_array_separator() throws {
+    @Test(.tags(.array))
+    func `[array] text before array separator`() throws {
         try invalidate(pathComponents: ["array", "text-before-array-separator"])
     }
 
-    @Test("[array] text in array", .tags(.array))
-    func array__text_in_array() throws {
+    @Test(.tags(.array))
+    func `[array] text in array`() throws {
         try invalidate(pathComponents: ["array", "text-in-array"])
     }
 
-    @Test("[bool] almost false", .tags(.bool))
-    func bool__almost_false() throws {
+    @Test(.tags(.bool))
+    func `[bool] almost false`() throws {
         try invalidate(pathComponents: ["bool", "almost-false"])
     }
 
-    @Test("[bool] almost false with extra", .tags(.bool))
-    func bool__almost_false_with_extra() throws {
+    @Test(.tags(.bool))
+    func `[bool] almost false with extra`() throws {
         try invalidate(pathComponents: ["bool", "almost-false-with-extra"])
     }
 
-    @Test("[bool] almost true", .tags(.bool))
-    func bool__almost_true() throws {
+    @Test(.tags(.bool))
+    func `[bool] almost true`() throws {
         try invalidate(pathComponents: ["bool", "almost-true"])
     }
 
-    @Test("[bool] almost true with extra", .tags(.bool))
-    func bool__almost_true_with_extra() throws {
+    @Test(.tags(.bool))
+    func `[bool] almost true with extra`() throws {
         try invalidate(pathComponents: ["bool", "almost-true-with-extra"])
     }
 
-    @Test("[bool] capitalized false", .tags(.bool))
-    func bool__capitalized_false() throws {
+    @Test(.tags(.bool))
+    func `[bool] capitalized false`() throws {
         try invalidate(pathComponents: ["bool", "capitalized-false"])
     }
 
-    @Test("[bool] capitalized true", .tags(.bool))
-    func bool__capitalized_true() throws {
+    @Test(.tags(.bool))
+    func `[bool] capitalized true`() throws {
         try invalidate(pathComponents: ["bool", "capitalized-true"])
     }
 
-    @Test("[bool] just f", .tags(.bool))
-    func bool__just_f() throws {
+    @Test(.tags(.bool))
+    func `[bool] just f`() throws {
         try invalidate(pathComponents: ["bool", "just-f"])
     }
 
-    @Test("[bool] just t", .tags(.bool))
-    func bool__just_t() throws {
+    @Test(.tags(.bool))
+    func `[bool] just t`() throws {
         try invalidate(pathComponents: ["bool", "just-t"])
     }
 
-    @Test("[bool] mixed case", .tags(.bool))
-    func bool__mixed_case() throws {
+    @Test(.tags(.bool))
+    func `[bool] mixed case`() throws {
         try invalidate(pathComponents: ["bool", "mixed-case"])
     }
 
-    @Test("[bool] mixed case false", .tags(.bool))
-    func bool__mixed_case_false() throws {
+    @Test(.tags(.bool))
+    func `[bool] mixed case false`() throws {
         try invalidate(pathComponents: ["bool", "mixed-case-false"])
     }
 
-    @Test("[bool] mixed case true", .tags(.bool))
-    func bool__mixed_case_true() throws {
+    @Test(.tags(.bool))
+    func `[bool] mixed case true`() throws {
         try invalidate(pathComponents: ["bool", "mixed-case-true"])
     }
 
-    @Test("[bool] starting same false", .tags(.bool))
-    func bool__starting_same_false() throws {
+    @Test(.tags(.bool))
+    func `[bool] starting same false`() throws {
         try invalidate(pathComponents: ["bool", "starting-same-false"])
     }
 
-    @Test("[bool] starting same true", .tags(.bool))
-    func bool__starting_same_true() throws {
+    @Test(.tags(.bool))
+    func `[bool] starting same true`() throws {
         try invalidate(pathComponents: ["bool", "starting-same-true"])
     }
 
-    @Test("[bool] wrong case false", .tags(.bool))
-    func bool__wrong_case_false() throws {
+    @Test(.tags(.bool))
+    func `[bool] wrong case false`() throws {
         try invalidate(pathComponents: ["bool", "wrong-case-false"])
     }
 
-    @Test("[bool] wrong case true", .tags(.bool))
-    func bool__wrong_case_true() throws {
+    @Test(.tags(.bool))
+    func `[bool] wrong case true`() throws {
         try invalidate(pathComponents: ["bool", "wrong-case-true"])
     }
 
-    @Test("[control] bare cr", .tags(.control))
-    func control__bare_cr() throws {
+    @Test(.tags(.control))
+    func `[control] bare cr`() throws {
         try invalidate(pathComponents: ["control", "bare-cr"])
     }
 
-    @Test("[control] bare formfeed", .tags(.control))
-    func control__bare_formfeed() throws {
+    @Test(.tags(.control))
+    func `[control] bare formfeed`() throws {
         try invalidate(pathComponents: ["control", "bare-formfeed"])
     }
 
-    @Test("[control] bare null", .tags(.control))
-    func control__bare_null() throws {
+    @Test(.tags(.control))
+    func `[control] bare null`() throws {
         try invalidate(pathComponents: ["control", "bare-null"])
     }
 
-    @Test("[control] bare vertical tab", .tags(.control))
-    func control__bare_vertical_tab() throws {
+    @Test(.tags(.control))
+    func `[control] bare vertical tab`() throws {
         try invalidate(pathComponents: ["control", "bare-vertical-tab"])
     }
 
-    @Test("[control] comment cr", .tags(.control))
-    func control__comment_cr() throws {
+    @Test(.tags(.control))
+    func `[control] comment cr`() throws {
         try invalidate(pathComponents: ["control", "comment-cr"])
     }
 
-    @Test("[control] comment del", .tags(.control))
-    func control__comment_del() throws {
+    @Test(.tags(.control))
+    func `[control] comment del`() throws {
         try invalidate(pathComponents: ["control", "comment-del"])
     }
 
-    @Test("[control] comment ff", .tags(.control))
-    func control__comment_ff() throws {
+    @Test(.tags(.control))
+    func `[control] comment ff`() throws {
         try invalidate(pathComponents: ["control", "comment-ff"])
     }
 
-    @Test("[control] comment lf", .tags(.control))
-    func control__comment_lf() throws {
+    @Test(.tags(.control))
+    func `[control] comment lf`() throws {
         try invalidate(pathComponents: ["control", "comment-lf"])
     }
 
-    @Test("[control] comment null", .tags(.control))
-    func control__comment_null() throws {
+    @Test(.tags(.control))
+    func `[control] comment null`() throws {
         try invalidate(pathComponents: ["control", "comment-null"])
     }
 
-    @Test("[control] comment us", .tags(.control))
-    func control__comment_us() throws {
+    @Test(.tags(.control))
+    func `[control] comment us`() throws {
         try invalidate(pathComponents: ["control", "comment-us"])
     }
 
-    @Test("[control] multi cr", .tags(.control))
-    func control__multi_cr() throws {
+    @Test(.tags(.control))
+    func `[control] multi cr`() throws {
         try invalidate(pathComponents: ["control", "multi-cr"])
     }
 
-    @Test("[control] multi del", .tags(.control))
-    func control__multi_del() throws {
+    @Test(.tags(.control))
+    func `[control] multi del`() throws {
         try invalidate(pathComponents: ["control", "multi-del"])
     }
 
-    @Test("[control] multi lf", .tags(.control))
-    func control__multi_lf() throws {
+    @Test(.tags(.control))
+    func `[control] multi lf`() throws {
         try invalidate(pathComponents: ["control", "multi-lf"])
     }
 
-    @Test("[control] multi null", .tags(.control))
-    func control__multi_null() throws {
+    @Test(.tags(.control))
+    func `[control] multi null`() throws {
         try invalidate(pathComponents: ["control", "multi-null"])
     }
 
-    @Test("[control] multi us", .tags(.control))
-    func control__multi_us() throws {
+    @Test(.tags(.control))
+    func `[control] multi us`() throws {
         try invalidate(pathComponents: ["control", "multi-us"])
     }
 
-    @Test("[control] only ff", .tags(.control))
-    func control__only_ff() throws {
+    @Test(.tags(.control))
+    func `[control] only ff`() throws {
         try invalidate(pathComponents: ["control", "only-ff"])
     }
 
-    @Test("[control] only null", .tags(.control))
-    func control__only_null() throws {
+    @Test(.tags(.control))
+    func `[control] only null`() throws {
         try invalidate(pathComponents: ["control", "only-null"])
     }
 
-    @Test("[control] only vt", .tags(.control))
-    func control__only_vt() throws {
+    @Test(.tags(.control))
+    func `[control] only vt`() throws {
         try invalidate(pathComponents: ["control", "only-vt"])
     }
 
-    @Test("[control] rawmulti cr", .tags(.control))
-    func control__rawmulti_cr() throws {
+    @Test(.tags(.control))
+    func `[control] rawmulti cr`() throws {
         try invalidate(pathComponents: ["control", "rawmulti-cr"])
     }
 
-    @Test("[control] rawmulti del", .tags(.control))
-    func control__rawmulti_del() throws {
+    @Test(.tags(.control))
+    func `[control] rawmulti del`() throws {
         try invalidate(pathComponents: ["control", "rawmulti-del"])
     }
 
-    @Test("[control] rawmulti lf", .tags(.control))
-    func control__rawmulti_lf() throws {
+    @Test(.tags(.control))
+    func `[control] rawmulti lf`() throws {
         try invalidate(pathComponents: ["control", "rawmulti-lf"])
     }
 
-    @Test("[control] rawmulti null", .tags(.control))
-    func control__rawmulti_null() throws {
+    @Test(.tags(.control))
+    func `[control] rawmulti null`() throws {
         try invalidate(pathComponents: ["control", "rawmulti-null"])
     }
 
-    @Test("[control] rawmulti us", .tags(.control))
-    func control__rawmulti_us() throws {
+    @Test(.tags(.control))
+    func `[control] rawmulti us`() throws {
         try invalidate(pathComponents: ["control", "rawmulti-us"])
     }
 
-    @Test("[control] rawstring cr", .tags(.control))
-    func control__rawstring_cr() throws {
+    @Test(.tags(.control))
+    func `[control] rawstring cr`() throws {
         try invalidate(pathComponents: ["control", "rawstring-cr"])
     }
 
-    @Test("[control] rawstring del", .tags(.control))
-    func control__rawstring_del() throws {
+    @Test(.tags(.control))
+    func `[control] rawstring del`() throws {
         try invalidate(pathComponents: ["control", "rawstring-del"])
     }
 
-    @Test("[control] rawstring lf", .tags(.control))
-    func control__rawstring_lf() throws {
+    @Test(.tags(.control))
+    func `[control] rawstring lf`() throws {
         try invalidate(pathComponents: ["control", "rawstring-lf"])
     }
 
-    @Test("[control] rawstring null", .tags(.control))
-    func control__rawstring_null() throws {
+    @Test(.tags(.control))
+    func `[control] rawstring null`() throws {
         try invalidate(pathComponents: ["control", "rawstring-null"])
     }
 
-    @Test("[control] rawstring us", .tags(.control))
-    func control__rawstring_us() throws {
+    @Test(.tags(.control))
+    func `[control] rawstring us`() throws {
         try invalidate(pathComponents: ["control", "rawstring-us"])
     }
 
-    @Test("[control] string bs", .tags(.control))
-    func control__string_bs() throws {
+    @Test(.tags(.control))
+    func `[control] string bs`() throws {
         try invalidate(pathComponents: ["control", "string-bs"])
     }
 
-    @Test("[control] string cr", .tags(.control))
-    func control__string_cr() throws {
+    @Test(.tags(.control))
+    func `[control] string cr`() throws {
         try invalidate(pathComponents: ["control", "string-cr"])
     }
 
-    @Test("[control] string del", .tags(.control))
-    func control__string_del() throws {
+    @Test(.tags(.control))
+    func `[control] string del`() throws {
         try invalidate(pathComponents: ["control", "string-del"])
     }
 
-    @Test("[control] string lf", .tags(.control))
-    func control__string_lf() throws {
+    @Test(.tags(.control))
+    func `[control] string lf`() throws {
         try invalidate(pathComponents: ["control", "string-lf"])
     }
 
-    @Test("[control] string null", .tags(.control))
-    func control__string_null() throws {
+    @Test(.tags(.control))
+    func `[control] string null`() throws {
         try invalidate(pathComponents: ["control", "string-null"])
     }
 
-    @Test("[control] string us", .tags(.control))
-    func control__string_us() throws {
+    @Test(.tags(.control))
+    func `[control] string us`() throws {
         try invalidate(pathComponents: ["control", "string-us"])
     }
 
-    @Test("[datetime] day zero", .tags(.datetime))
-    func datetime__day_zero() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] day zero`() throws {
         try invalidate(pathComponents: ["datetime", "day-zero"])
     }
 
-    @Test("[datetime] feb 29", .tags(.datetime))
-    func datetime__feb_29() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] feb 29`() throws {
         try invalidate(pathComponents: ["datetime", "feb-29"])
     }
 
-    @Test("[datetime] feb 30", .tags(.datetime))
-    func datetime__feb_30() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] feb 30`() throws {
         try invalidate(pathComponents: ["datetime", "feb-30"])
     }
 
-    @Test("[datetime] hour over", .tags(.datetime))
-    func datetime__hour_over() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] hour over`() throws {
         try invalidate(pathComponents: ["datetime", "hour-over"])
     }
 
-    @Test("[datetime] mday over", .tags(.datetime))
-    func datetime__mday_over() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] mday over`() throws {
         try invalidate(pathComponents: ["datetime", "mday-over"])
     }
 
-    @Test("[datetime] mday under", .tags(.datetime))
-    func datetime__mday_under() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] mday under`() throws {
         try invalidate(pathComponents: ["datetime", "mday-under"])
     }
 
-    @Test("[datetime] minute over", .tags(.datetime))
-    func datetime__minute_over() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] minute over`() throws {
         try invalidate(pathComponents: ["datetime", "minute-over"])
     }
 
-    @Test("[datetime] month over", .tags(.datetime))
-    func datetime__month_over() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] month over`() throws {
         try invalidate(pathComponents: ["datetime", "month-over"])
     }
 
-    @Test("[datetime] month under", .tags(.datetime))
-    func datetime__month_under() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] month under`() throws {
         try invalidate(pathComponents: ["datetime", "month-under"])
     }
 
-    @Test("[datetime] no date time sep", .tags(.datetime))
-    func datetime__no_date_time_sep() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] no date time sep`() throws {
         try invalidate(pathComponents: ["datetime", "no-date-time-sep"])
     }
 
-    @Test("[datetime] no leads", .tags(.datetime))
-    func datetime__no_leads() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] no leads`() throws {
         try invalidate(pathComponents: ["datetime", "no-leads"])
     }
 
-    @Test("[datetime] no leads month", .tags(.datetime))
-    func datetime__no_leads_month() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] no leads month`() throws {
         try invalidate(pathComponents: ["datetime", "no-leads-month"])
     }
 
-    @Test("[datetime] no leads with milli", .tags(.datetime))
-    func datetime__no_leads_with_milli() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] no leads with milli`() throws {
         try invalidate(pathComponents: ["datetime", "no-leads-with-milli"])
     }
 
-    @Test("[datetime] no t", .tags(.datetime))
-    func datetime__no_t() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] no t`() throws {
         try invalidate(pathComponents: ["datetime", "no-t"])
     }
 
-    @Test("[datetime] no year month sep", .tags(.datetime))
-    func datetime__no_year_month_sep() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] no year month sep`() throws {
         try invalidate(pathComponents: ["datetime", "no-year-month-sep"])
     }
 
-    @Test("[datetime] offset minus minute 1digit", .tags(.datetime))
-    func datetime__offset_minus_minute_1digit() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] offset minus minute 1digit`() throws {
         try invalidate(pathComponents: ["datetime", "offset-minus-minute-1digit"])
     }
 
-    @Test("[datetime] offset minus no hour minute", .tags(.datetime))
-    func datetime__offset_minus_no_hour_minute() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] offset minus no hour minute`() throws {
         try invalidate(pathComponents: ["datetime", "offset-minus-no-hour-minute"])
     }
 
-    @Test("[datetime] offset minus no hour minute sep", .tags(.datetime))
-    func datetime__offset_minus_no_hour_minute_sep() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] offset minus no hour minute sep`() throws {
         try invalidate(pathComponents: ["datetime", "offset-minus-no-hour-minute-sep"])
     }
 
-    @Test("[datetime] offset minus no minute", .tags(.datetime))
-    func datetime__offset_minus_no_minute() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] offset minus no minute`() throws {
         try invalidate(pathComponents: ["datetime", "offset-minus-no-minute"])
     }
 
-    @Test("[datetime] offset overflow hour", .tags(.datetime))
-    func datetime__offset_overflow_hour() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] offset overflow hour`() throws {
         try invalidate(pathComponents: ["datetime", "offset-overflow-hour"])
     }
 
-    @Test("[datetime] offset overflow minute", .tags(.datetime))
-    func datetime__offset_overflow_minute() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] offset overflow minute`() throws {
         try invalidate(pathComponents: ["datetime", "offset-overflow-minute"])
     }
 
-    @Test("[datetime] offset plus minute 1digit", .tags(.datetime))
-    func datetime__offset_plus_minute_1digit() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] offset plus minute 1digit`() throws {
         try invalidate(pathComponents: ["datetime", "offset-plus-minute-1digit"])
     }
 
-    @Test("[datetime] offset plus no hour minute", .tags(.datetime))
-    func datetime__offset_plus_no_hour_minute() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] offset plus no hour minute`() throws {
         try invalidate(pathComponents: ["datetime", "offset-plus-no-hour-minute"])
     }
 
-    @Test("[datetime] offset plus no hour minute sep", .tags(.datetime))
-    func datetime__offset_plus_no_hour_minute_sep() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] offset plus no hour minute sep`() throws {
         try invalidate(pathComponents: ["datetime", "offset-plus-no-hour-minute-sep"])
     }
 
-    @Test("[datetime] offset plus no minute", .tags(.datetime))
-    func datetime__offset_plus_no_minute() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] offset plus no minute`() throws {
         try invalidate(pathComponents: ["datetime", "offset-plus-no-minute"])
     }
 
-    @Test("[datetime] only T", .tags(.datetime))
-    func datetime__only_T() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] only T`() throws {
         try invalidate(pathComponents: ["datetime", "only-T"])
     }
 
-    @Test("[datetime] only TZ", .tags(.datetime))
-    func datetime__only_TZ() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] only TZ`() throws {
         try invalidate(pathComponents: ["datetime", "only-TZ"])
     }
 
-    @Test("[datetime] only Tdot", .tags(.datetime))
-    func datetime__only_Tdot() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] only Tdot`() throws {
         try invalidate(pathComponents: ["datetime", "only-Tdot"])
     }
 
-    @Test("[datetime] second over", .tags(.datetime))
-    func datetime__second_over() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] second over`() throws {
         try invalidate(pathComponents: ["datetime", "second-over"])
     }
 
-    @Test("[datetime] second trailing dot", .tags(.datetime))
-    func datetime__second_trailing_dot() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] second trailing dot`() throws {
         try invalidate(pathComponents: ["datetime", "second-trailing-dot"])
     }
 
-    @Test("[datetime] second trailing dotz", .tags(.datetime))
-    func datetime__second_trailing_dotz() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] second trailing dotz`() throws {
         try invalidate(pathComponents: ["datetime", "second-trailing-dotz"])
     }
 
-    @Test("[datetime] time no leads", .tags(.datetime))
-    func datetime__time_no_leads() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] time no leads`() throws {
         try invalidate(pathComponents: ["datetime", "time-no-leads"])
     }
 
-    @Test("[datetime] trailing x", .tags(.datetime))
-    func datetime__trailing_x() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] trailing x`() throws {
         try invalidate(pathComponents: ["datetime", "trailing-x"])
     }
 
-    @Test("[datetime] y10k", .tags(.datetime))
-    func datetime__y10k() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] y10k`() throws {
         try invalidate(pathComponents: ["datetime", "y10k"])
     }
 
-    @Test("[encoding] bad codepoint", .tags(.encoding))
-    func encoding__bad_codepoint() throws {
+    @Test(.tags(.encoding))
+    func `[encoding] bad codepoint`() throws {
         try invalidate(pathComponents: ["encoding", "bad-codepoint"])
     }
 
-    @Test("[encoding] bad utf8 at end", .tags(.encoding))
-    func encoding__bad_utf8_at_end() throws {
+    @Test(.tags(.encoding))
+    func `[encoding] bad utf8 at end`() throws {
         try invalidate(pathComponents: ["encoding", "bad-utf8-at-end"])
     }
 
-    @Test("[encoding] bad utf8 in array", .tags(.encoding))
-    func encoding__bad_utf8_in_array() throws {
+    @Test(.tags(.encoding))
+    func `[encoding] bad utf8 in array`() throws {
         try invalidate(pathComponents: ["encoding", "bad-utf8-in-array"])
     }
 
-    @Test("[encoding] bad utf8 in comment", .tags(.encoding))
-    func encoding__bad_utf8_in_comment() throws {
+    @Test(.tags(.encoding))
+    func `[encoding] bad utf8 in comment`() throws {
         try invalidate(pathComponents: ["encoding", "bad-utf8-in-comment"])
     }
 
-    @Test("[encoding] bad utf8 in multiline", .tags(.encoding))
-    func encoding__bad_utf8_in_multiline() throws {
+    @Test(.tags(.encoding))
+    func `[encoding] bad utf8 in multiline`() throws {
         try invalidate(pathComponents: ["encoding", "bad-utf8-in-multiline"])
     }
 
-    @Test("[encoding] bad utf8 in multiline literal", .tags(.encoding))
-    func encoding__bad_utf8_in_multiline_literal() throws {
+    @Test(.tags(.encoding))
+    func `[encoding] bad utf8 in multiline literal`() throws {
         try invalidate(pathComponents: ["encoding", "bad-utf8-in-multiline-literal"])
     }
 
-    @Test("[encoding] bad utf8 in string", .tags(.encoding))
-    func encoding__bad_utf8_in_string() throws {
+    @Test(.tags(.encoding))
+    func `[encoding] bad utf8 in string`() throws {
         try invalidate(pathComponents: ["encoding", "bad-utf8-in-string"])
     }
 
-    @Test("[encoding] bad utf8 in string literal", .tags(.encoding))
-    func encoding__bad_utf8_in_string_literal() throws {
+    @Test(.tags(.encoding))
+    func `[encoding] bad utf8 in string literal`() throws {
         try invalidate(pathComponents: ["encoding", "bad-utf8-in-string-literal"])
     }
 
-    @Test("[encoding] bom not at start 01", .tags(.encoding))
-    func encoding__bom_not_at_start_01() throws {
+    @Test(.tags(.encoding))
+    func `[encoding] bom not at start 01`() throws {
         try invalidate(pathComponents: ["encoding", "bom-not-at-start-01"])
     }
 
-    @Test("[encoding] bom not at start 02", .tags(.encoding))
-    func encoding__bom_not_at_start_02() throws {
+    @Test(.tags(.encoding))
+    func `[encoding] bom not at start 02`() throws {
         try invalidate(pathComponents: ["encoding", "bom-not-at-start-02"])
     }
 
-    @Test("[encoding] ideographic space", .tags(.encoding))
-    func encoding__ideographic_space() throws {
+    @Test(.tags(.encoding))
+    func `[encoding] ideographic space`() throws {
         try invalidate(pathComponents: ["encoding", "ideographic-space"])
     }
 
-    @Test("[encoding] utf16 bom", .tags(.encoding))
-    func encoding__utf16_bom() throws {
+    @Test(.tags(.encoding))
+    func `[encoding] utf16 bom`() throws {
         try invalidate(pathComponents: ["encoding", "utf16-bom"])
     }
 
-    @Test("[encoding] utf16 comment", .tags(.encoding))
-    func encoding__utf16_comment() throws {
+    @Test(.tags(.encoding))
+    func `[encoding] utf16 comment`() throws {
         try invalidate(pathComponents: ["encoding", "utf16-comment"])
     }
 
-    @Test("[encoding] utf16 key", .tags(.encoding))
-    func encoding__utf16_key() throws {
+    @Test(.tags(.encoding))
+    func `[encoding] utf16 key`() throws {
         try invalidate(pathComponents: ["encoding", "utf16-key"])
     }
 
-    @Test("[float] double dot 01", .tags(.float))
-    func float__double_dot_01() throws {
+    @Test(.tags(.float))
+    func `[float] double dot 01`() throws {
         try invalidate(pathComponents: ["float", "double-dot-01"])
     }
 
-    @Test("[float] double dot 02", .tags(.float))
-    func float__double_dot_02() throws {
+    @Test(.tags(.float))
+    func `[float] double dot 02`() throws {
         try invalidate(pathComponents: ["float", "double-dot-02"])
     }
 
-    @Test("[float] exp dot 01", .tags(.float))
-    func float__exp_dot_01() throws {
+    @Test(.tags(.float))
+    func `[float] exp dot 01`() throws {
         try invalidate(pathComponents: ["float", "exp-dot-01"])
     }
 
-    @Test("[float] exp dot 02", .tags(.float))
-    func float__exp_dot_02() throws {
+    @Test(.tags(.float))
+    func `[float] exp dot 02`() throws {
         try invalidate(pathComponents: ["float", "exp-dot-02"])
     }
 
-    @Test("[float] exp dot 03", .tags(.float))
-    func float__exp_dot_03() throws {
+    @Test(.tags(.float))
+    func `[float] exp dot 03`() throws {
         try invalidate(pathComponents: ["float", "exp-dot-03"])
     }
 
-    @Test("[float] exp double e 01", .tags(.float))
-    func float__exp_double_e_01() throws {
+    @Test(.tags(.float))
+    func `[float] exp double e 01`() throws {
         try invalidate(pathComponents: ["float", "exp-double-e-01"])
     }
 
-    @Test("[float] exp double e 02", .tags(.float))
-    func float__exp_double_e_02() throws {
+    @Test(.tags(.float))
+    func `[float] exp double e 02`() throws {
         try invalidate(pathComponents: ["float", "exp-double-e-02"])
     }
 
-    @Test("[float] exp double us", .tags(.float))
-    func float__exp_double_us() throws {
+    @Test(.tags(.float))
+    func `[float] exp double us`() throws {
         try invalidate(pathComponents: ["float", "exp-double-us"])
     }
 
-    @Test("[float] exp leading us", .tags(.float))
-    func float__exp_leading_us() throws {
+    @Test(.tags(.float))
+    func `[float] exp leading us`() throws {
         try invalidate(pathComponents: ["float", "exp-leading-us"])
     }
 
-    @Test("[float] exp trailing us", .tags(.float))
-    func float__exp_trailing_us() throws {
+    @Test(.tags(.float))
+    func `[float] exp trailing us`() throws {
         try invalidate(pathComponents: ["float", "exp-trailing-us"])
     }
 
-    @Test("[float] exp trailing us 01", .tags(.float))
-    func float__exp_trailing_us_01() throws {
+    @Test(.tags(.float))
+    func `[float] exp trailing us 01`() throws {
         try invalidate(pathComponents: ["float", "exp-trailing-us-01"])
     }
 
-    @Test("[float] exp trailing us 02", .tags(.float))
-    func float__exp_trailing_us_02() throws {
+    @Test(.tags(.float))
+    func `[float] exp trailing us 02`() throws {
         try invalidate(pathComponents: ["float", "exp-trailing-us-02"])
     }
 
-    @Test("[float] inf capital", .tags(.float))
-    func float__inf_capital() throws {
+    @Test(.tags(.float))
+    func `[float] inf capital`() throws {
         try invalidate(pathComponents: ["float", "inf-capital"])
     }
 
-    @Test("[float] inf incomplete 01", .tags(.float))
-    func float__inf_incomplete_01() throws {
+    @Test(.tags(.float))
+    func `[float] inf incomplete 01`() throws {
         try invalidate(pathComponents: ["float", "inf-incomplete-01"])
     }
 
-    @Test("[float] inf incomplete 02", .tags(.float))
-    func float__inf_incomplete_02() throws {
+    @Test(.tags(.float))
+    func `[float] inf incomplete 02`() throws {
         try invalidate(pathComponents: ["float", "inf-incomplete-02"])
     }
 
-    @Test("[float] inf incomplete 03", .tags(.float))
-    func float__inf_incomplete_03() throws {
+    @Test(.tags(.float))
+    func `[float] inf incomplete 03`() throws {
         try invalidate(pathComponents: ["float", "inf-incomplete-03"])
     }
 
-    @Test("[float] inf underscore", .tags(.float))
-    func float__inf_underscore() throws {
+    @Test(.tags(.float))
+    func `[float] inf underscore`() throws {
         try invalidate(pathComponents: ["float", "inf_underscore"])
     }
 
-    @Test("[float] leading dot", .tags(.float))
-    func float__leading_dot() throws {
+    @Test(.tags(.float))
+    func `[float] leading dot`() throws {
         try invalidate(pathComponents: ["float", "leading-dot"])
     }
 
-    @Test("[float] leading dot neg", .tags(.float))
-    func float__leading_dot_neg() throws {
+    @Test(.tags(.float))
+    func `[float] leading dot neg`() throws {
         try invalidate(pathComponents: ["float", "leading-dot-neg"])
     }
 
-    @Test("[float] leading dot plus", .tags(.float))
-    func float__leading_dot_plus() throws {
+    @Test(.tags(.float))
+    func `[float] leading dot plus`() throws {
         try invalidate(pathComponents: ["float", "leading-dot-plus"])
     }
 
-    @Test("[float] leading us", .tags(.float))
-    func float__leading_us() throws {
+    @Test(.tags(.float))
+    func `[float] leading us`() throws {
         try invalidate(pathComponents: ["float", "leading-us"])
     }
 
-    @Test("[float] leading zero", .tags(.float))
-    func float__leading_zero() throws {
+    @Test(.tags(.float))
+    func `[float] leading zero`() throws {
         try invalidate(pathComponents: ["float", "leading-zero"])
     }
 
-    @Test("[float] leading zero neg", .tags(.float))
-    func float__leading_zero_neg() throws {
+    @Test(.tags(.float))
+    func `[float] leading zero neg`() throws {
         try invalidate(pathComponents: ["float", "leading-zero-neg"])
     }
 
-    @Test("[float] leading zero plus", .tags(.float))
-    func float__leading_zero_plus() throws {
+    @Test(.tags(.float))
+    func `[float] leading zero plus`() throws {
         try invalidate(pathComponents: ["float", "leading-zero-plus"])
     }
 
-    @Test("[float] nan capital", .tags(.float))
-    func float__nan_capital() throws {
+    @Test(.tags(.float))
+    func `[float] nan capital`() throws {
         try invalidate(pathComponents: ["float", "nan-capital"])
     }
 
-    @Test("[float] nan incomplete 01", .tags(.float))
-    func float__nan_incomplete_01() throws {
+    @Test(.tags(.float))
+    func `[float] nan incomplete 01`() throws {
         try invalidate(pathComponents: ["float", "nan-incomplete-01"])
     }
 
-    @Test("[float] nan incomplete 02", .tags(.float))
-    func float__nan_incomplete_02() throws {
+    @Test(.tags(.float))
+    func `[float] nan incomplete 02`() throws {
         try invalidate(pathComponents: ["float", "nan-incomplete-02"])
     }
 
-    @Test("[float] nan incomplete 03", .tags(.float))
-    func float__nan_incomplete_03() throws {
+    @Test(.tags(.float))
+    func `[float] nan incomplete 03`() throws {
         try invalidate(pathComponents: ["float", "nan-incomplete-03"])
     }
 
-    @Test("[float] nan underscore", .tags(.float))
-    func float__nan_underscore() throws {
+    @Test(.tags(.float))
+    func `[float] nan underscore`() throws {
         try invalidate(pathComponents: ["float", "nan_underscore"])
     }
 
-    @Test("[float] trailing dot", .tags(.float))
-    func float__trailing_dot() throws {
+    @Test(.tags(.float))
+    func `[float] trailing dot`() throws {
         try invalidate(pathComponents: ["float", "trailing-dot"])
     }
 
-    @Test("[float] trailing dot 01", .tags(.float))
-    func float__trailing_dot_01() throws {
+    @Test(.tags(.float))
+    func `[float] trailing dot 01`() throws {
         try invalidate(pathComponents: ["float", "trailing-dot-01"])
     }
 
-    @Test("[float] trailing dot 02", .tags(.float))
-    func float__trailing_dot_02() throws {
+    @Test(.tags(.float))
+    func `[float] trailing dot 02`() throws {
         try invalidate(pathComponents: ["float", "trailing-dot-02"])
     }
 
-    @Test("[float] trailing dot min", .tags(.float))
-    func float__trailing_dot_min() throws {
+    @Test(.tags(.float))
+    func `[float] trailing dot min`() throws {
         try invalidate(pathComponents: ["float", "trailing-dot-min"])
     }
 
-    @Test("[float] trailing dot plus", .tags(.float))
-    func float__trailing_dot_plus() throws {
+    @Test(.tags(.float))
+    func `[float] trailing dot plus`() throws {
         try invalidate(pathComponents: ["float", "trailing-dot-plus"])
     }
 
-    @Test("[float] trailing exp", .tags(.float))
-    func float__trailing_exp() throws {
+    @Test(.tags(.float))
+    func `[float] trailing exp`() throws {
         try invalidate(pathComponents: ["float", "trailing-exp"])
     }
 
-    @Test("[float] trailing exp dot", .tags(.float))
-    func float__trailing_exp_dot() throws {
+    @Test(.tags(.float))
+    func `[float] trailing exp dot`() throws {
         try invalidate(pathComponents: ["float", "trailing-exp-dot"])
     }
 
-    @Test("[float] trailing exp minus", .tags(.float))
-    func float__trailing_exp_minus() throws {
+    @Test(.tags(.float))
+    func `[float] trailing exp minus`() throws {
         try invalidate(pathComponents: ["float", "trailing-exp-minus"])
     }
 
-    @Test("[float] trailing exp plus", .tags(.float))
-    func float__trailing_exp_plus() throws {
+    @Test(.tags(.float))
+    func `[float] trailing exp plus`() throws {
         try invalidate(pathComponents: ["float", "trailing-exp-plus"])
     }
 
-    @Test("[float] trailing us", .tags(.float))
-    func float__trailing_us() throws {
+    @Test(.tags(.float))
+    func `[float] trailing us`() throws {
         try invalidate(pathComponents: ["float", "trailing-us"])
     }
 
-    @Test("[float] trailing us exp 01", .tags(.float))
-    func float__trailing_us_exp_01() throws {
+    @Test(.tags(.float))
+    func `[float] trailing us exp 01`() throws {
         try invalidate(pathComponents: ["float", "trailing-us-exp-01"])
     }
 
-    @Test("[float] trailing us exp 02", .tags(.float))
-    func float__trailing_us_exp_02() throws {
+    @Test(.tags(.float))
+    func `[float] trailing us exp 02`() throws {
         try invalidate(pathComponents: ["float", "trailing-us-exp-02"])
     }
 
-    @Test("[float] us after dot", .tags(.float))
-    func float__us_after_dot() throws {
+    @Test(.tags(.float))
+    func `[float] us after dot`() throws {
         try invalidate(pathComponents: ["float", "us-after-dot"])
     }
 
-    @Test("[float] us before dot", .tags(.float))
-    func float__us_before_dot() throws {
+    @Test(.tags(.float))
+    func `[float] us before dot`() throws {
         try invalidate(pathComponents: ["float", "us-before-dot"])
     }
 
-    @Test("[inline-table] bad key syntax", .tags(.inline_table))
-    func inline_table__bad_key_syntax() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] bad key syntax`() throws {
         try invalidate(pathComponents: ["inline-table", "bad-key-syntax"])
     }
 
-    @Test("[inline-table] double comma", .tags(.inline_table))
-    func inline_table__double_comma() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] double comma`() throws {
         try invalidate(pathComponents: ["inline-table", "double-comma"])
     }
 
-    @Test("[inline-table] duplicate key 01", .tags(.inline_table))
-    func inline_table__duplicate_key_01() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] duplicate key 01`() throws {
         try invalidate(pathComponents: ["inline-table", "duplicate-key-01"])
     }
 
-    @Test("[inline-table] duplicate key 02", .tags(.inline_table))
-    func inline_table__duplicate_key_02() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] duplicate key 02`() throws {
         try invalidate(pathComponents: ["inline-table", "duplicate-key-02"])
     }
 
-    @Test("[inline-table] duplicate key 03", .tags(.inline_table))
-    func inline_table__duplicate_key_03() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] duplicate key 03`() throws {
         try invalidate(pathComponents: ["inline-table", "duplicate-key-03"])
     }
 
-    @Test("[inline-table] duplicate key 04", .tags(.inline_table))
-    func inline_table__duplicate_key_04() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] duplicate key 04`() throws {
         try invalidate(pathComponents: ["inline-table", "duplicate-key-04"])
     }
 
-    @Test("[inline-table] empty 01", .tags(.inline_table))
-    func inline_table__empty_01() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] empty 01`() throws {
         try invalidate(pathComponents: ["inline-table", "empty-01"])
     }
 
-    @Test("[inline-table] empty 02", .tags(.inline_table))
-    func inline_table__empty_02() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] empty 02`() throws {
         try invalidate(pathComponents: ["inline-table", "empty-02"])
     }
 
-    @Test("[inline-table] empty 03", .tags(.inline_table))
-    func inline_table__empty_03() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] empty 03`() throws {
         try invalidate(pathComponents: ["inline-table", "empty-03"])
     }
 
-    @Test("[inline-table] no close 01", .tags(.inline_table))
-    func inline_table__no_close_01() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] no close 01`() throws {
         try invalidate(pathComponents: ["inline-table", "no-close-01"])
     }
 
-    @Test("[inline-table] no close 02", .tags(.inline_table))
-    func inline_table__no_close_02() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] no close 02`() throws {
         try invalidate(pathComponents: ["inline-table", "no-close-02"])
     }
 
-    @Test("[inline-table] no comma 01", .tags(.inline_table))
-    func inline_table__no_comma_01() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] no comma 01`() throws {
         try invalidate(pathComponents: ["inline-table", "no-comma-01"])
     }
 
-    @Test("[inline-table] no comma 02", .tags(.inline_table))
-    func inline_table__no_comma_02() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] no comma 02`() throws {
         try invalidate(pathComponents: ["inline-table", "no-comma-02"])
     }
 
-    @Test("[inline-table] overwrite 01", .tags(.inline_table))
-    func inline_table__overwrite_01() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] overwrite 01`() throws {
         try invalidate(pathComponents: ["inline-table", "overwrite-01"])
     }
 
-    @Test("[inline-table] overwrite 02", .tags(.inline_table))
-    func inline_table__overwrite_02() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] overwrite 02`() throws {
         try invalidate(pathComponents: ["inline-table", "overwrite-02"])
     }
 
-    @Test("[inline-table] overwrite 03", .tags(.inline_table))
-    func inline_table__overwrite_03() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] overwrite 03`() throws {
         try invalidate(pathComponents: ["inline-table", "overwrite-03"])
     }
 
-    @Test("[inline-table] overwrite 04", .tags(.inline_table))
-    func inline_table__overwrite_04() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] overwrite 04`() throws {
         try invalidate(pathComponents: ["inline-table", "overwrite-04"])
     }
 
-    @Test("[inline-table] overwrite 05", .tags(.inline_table))
-    func inline_table__overwrite_05() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] overwrite 05`() throws {
         try invalidate(pathComponents: ["inline-table", "overwrite-05"])
     }
 
-    @Test("[inline-table] overwrite 06", .tags(.inline_table))
-    func inline_table__overwrite_06() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] overwrite 06`() throws {
         try invalidate(pathComponents: ["inline-table", "overwrite-06"])
     }
 
-    @Test("[inline-table] overwrite 07", .tags(.inline_table))
-    func inline_table__overwrite_07() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] overwrite 07`() throws {
         try invalidate(pathComponents: ["inline-table", "overwrite-07"])
     }
 
-    @Test("[inline-table] overwrite 08", .tags(.inline_table))
-    func inline_table__overwrite_08() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] overwrite 08`() throws {
         try invalidate(pathComponents: ["inline-table", "overwrite-08"])
     }
 
-    @Test("[inline-table] overwrite 09", .tags(.inline_table))
-    func inline_table__overwrite_09() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] overwrite 09`() throws {
         try invalidate(pathComponents: ["inline-table", "overwrite-09"])
     }
 
-    @Test("[inline-table] overwrite 10", .tags(.inline_table))
-    func inline_table__overwrite_10() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] overwrite 10`() throws {
         try invalidate(pathComponents: ["inline-table", "overwrite-10"])
     }
 
-    @Test("[integer] capital bin", .tags(.integer))
-    func integer__capital_bin() throws {
+    @Test(.tags(.integer))
+    func `[integer] capital bin`() throws {
         try invalidate(pathComponents: ["integer", "capital-bin"])
     }
 
-    @Test("[integer] capital hex", .tags(.integer))
-    func integer__capital_hex() throws {
+    @Test(.tags(.integer))
+    func `[integer] capital hex`() throws {
         try invalidate(pathComponents: ["integer", "capital-hex"])
     }
 
-    @Test("[integer] capital oct", .tags(.integer))
-    func integer__capital_oct() throws {
+    @Test(.tags(.integer))
+    func `[integer] capital oct`() throws {
         try invalidate(pathComponents: ["integer", "capital-oct"])
     }
 
-    @Test("[integer] double sign nex", .tags(.integer))
-    func integer__double_sign_nex() throws {
+    @Test(.tags(.integer))
+    func `[integer] double sign nex`() throws {
         try invalidate(pathComponents: ["integer", "double-sign-nex"])
     }
 
-    @Test("[integer] double sign plus", .tags(.integer))
-    func integer__double_sign_plus() throws {
+    @Test(.tags(.integer))
+    func `[integer] double sign plus`() throws {
         try invalidate(pathComponents: ["integer", "double-sign-plus"])
     }
 
-    @Test("[integer] double us", .tags(.integer))
-    func integer__double_us() throws {
+    @Test(.tags(.integer))
+    func `[integer] double us`() throws {
         try invalidate(pathComponents: ["integer", "double-us"])
     }
 
-    @Test("[integer] incomplete bin", .tags(.integer))
-    func integer__incomplete_bin() throws {
+    @Test(.tags(.integer))
+    func `[integer] incomplete bin`() throws {
         try invalidate(pathComponents: ["integer", "incomplete-bin"])
     }
 
-    @Test("[integer] incomplete hex", .tags(.integer))
-    func integer__incomplete_hex() throws {
+    @Test(.tags(.integer))
+    func `[integer] incomplete hex`() throws {
         try invalidate(pathComponents: ["integer", "incomplete-hex"])
     }
 
-    @Test("[integer] incomplete oct", .tags(.integer))
-    func integer__incomplete_oct() throws {
+    @Test(.tags(.integer))
+    func `[integer] incomplete oct`() throws {
         try invalidate(pathComponents: ["integer", "incomplete-oct"])
     }
 
-    @Test("[integer] invalid bin", .tags(.integer))
-    func integer__invalid_bin() throws {
+    @Test(.tags(.integer))
+    func `[integer] invalid bin`() throws {
         try invalidate(pathComponents: ["integer", "invalid-bin"])
     }
 
-    @Test("[integer] invalid hex 01", .tags(.integer))
-    func integer__invalid_hex_01() throws {
+    @Test(.tags(.integer))
+    func `[integer] invalid hex 01`() throws {
         try invalidate(pathComponents: ["integer", "invalid-hex-01"])
     }
 
-    @Test("[integer] invalid hex 02", .tags(.integer))
-    func integer__invalid_hex_02() throws {
+    @Test(.tags(.integer))
+    func `[integer] invalid hex 02`() throws {
         try invalidate(pathComponents: ["integer", "invalid-hex-02"])
     }
 
-    @Test("[integer] invalid hex 03", .tags(.integer))
-    func integer__invalid_hex_03() throws {
+    @Test(.tags(.integer))
+    func `[integer] invalid hex 03`() throws {
         try invalidate(pathComponents: ["integer", "invalid-hex-03"])
     }
 
-    @Test("[integer] invalid oct", .tags(.integer))
-    func integer__invalid_oct() throws {
+    @Test(.tags(.integer))
+    func `[integer] invalid oct`() throws {
         try invalidate(pathComponents: ["integer", "invalid-oct"])
     }
 
-    @Test("[integer] leading us", .tags(.integer))
-    func integer__leading_us() throws {
+    @Test(.tags(.integer))
+    func `[integer] leading us`() throws {
         try invalidate(pathComponents: ["integer", "leading-us"])
     }
 
-    @Test("[integer] leading us bin", .tags(.integer))
-    func integer__leading_us_bin() throws {
+    @Test(.tags(.integer))
+    func `[integer] leading us bin`() throws {
         try invalidate(pathComponents: ["integer", "leading-us-bin"])
     }
 
-    @Test("[integer] leading us hex", .tags(.integer))
-    func integer__leading_us_hex() throws {
+    @Test(.tags(.integer))
+    func `[integer] leading us hex`() throws {
         try invalidate(pathComponents: ["integer", "leading-us-hex"])
     }
 
-    @Test("[integer] leading us oct", .tags(.integer))
-    func integer__leading_us_oct() throws {
+    @Test(.tags(.integer))
+    func `[integer] leading us oct`() throws {
         try invalidate(pathComponents: ["integer", "leading-us-oct"])
     }
 
-    @Test("[integer] leading zero 01", .tags(.integer))
-    func integer__leading_zero_01() throws {
+    @Test(.tags(.integer))
+    func `[integer] leading zero 01`() throws {
         try invalidate(pathComponents: ["integer", "leading-zero-01"])
     }
 
-    @Test("[integer] leading zero 02", .tags(.integer))
-    func integer__leading_zero_02() throws {
+    @Test(.tags(.integer))
+    func `[integer] leading zero 02`() throws {
         try invalidate(pathComponents: ["integer", "leading-zero-02"])
     }
 
-    @Test("[integer] leading zero 03", .tags(.integer))
-    func integer__leading_zero_03() throws {
+    @Test(.tags(.integer))
+    func `[integer] leading zero 03`() throws {
         try invalidate(pathComponents: ["integer", "leading-zero-03"])
     }
 
-    @Test("[integer] leading zero sign 01", .tags(.integer))
-    func integer__leading_zero_sign_01() throws {
+    @Test(.tags(.integer))
+    func `[integer] leading zero sign 01`() throws {
         try invalidate(pathComponents: ["integer", "leading-zero-sign-01"])
     }
 
-    @Test("[integer] leading zero sign 02", .tags(.integer))
-    func integer__leading_zero_sign_02() throws {
+    @Test(.tags(.integer))
+    func `[integer] leading zero sign 02`() throws {
         try invalidate(pathComponents: ["integer", "leading-zero-sign-02"])
     }
 
-    @Test("[integer] leading zero sign 03", .tags(.integer))
-    func integer__leading_zero_sign_03() throws {
+    @Test(.tags(.integer))
+    func `[integer] leading zero sign 03`() throws {
         try invalidate(pathComponents: ["integer", "leading-zero-sign-03"])
     }
 
-    @Test("[integer] negative bin", .tags(.integer))
-    func integer__negative_bin() throws {
+    @Test(.tags(.integer))
+    func `[integer] negative bin`() throws {
         try invalidate(pathComponents: ["integer", "negative-bin"])
     }
 
-    @Test("[integer] negative hex", .tags(.integer))
-    func integer__negative_hex() throws {
+    @Test(.tags(.integer))
+    func `[integer] negative hex`() throws {
         try invalidate(pathComponents: ["integer", "negative-hex"])
     }
 
-    @Test("[integer] negative oct", .tags(.integer))
-    func integer__negative_oct() throws {
+    @Test(.tags(.integer))
+    func `[integer] negative oct`() throws {
         try invalidate(pathComponents: ["integer", "negative-oct"])
     }
 
-    @Test("[integer] positive bin", .tags(.integer))
-    func integer__positive_bin() throws {
+    @Test(.tags(.integer))
+    func `[integer] positive bin`() throws {
         try invalidate(pathComponents: ["integer", "positive-bin"])
     }
 
-    @Test("[integer] positive hex", .tags(.integer))
-    func integer__positive_hex() throws {
+    @Test(.tags(.integer))
+    func `[integer] positive hex`() throws {
         try invalidate(pathComponents: ["integer", "positive-hex"])
     }
 
-    @Test("[integer] positive oct", .tags(.integer))
-    func integer__positive_oct() throws {
+    @Test(.tags(.integer))
+    func `[integer] positive oct`() throws {
         try invalidate(pathComponents: ["integer", "positive-oct"])
     }
 
-    @Test("[integer] text after integer", .tags(.integer))
-    func integer__text_after_integer() throws {
+    @Test(.tags(.integer))
+    func `[integer] text after integer`() throws {
         try invalidate(pathComponents: ["integer", "text-after-integer"])
     }
 
-    @Test("[integer] trailing us", .tags(.integer))
-    func integer__trailing_us() throws {
+    @Test(.tags(.integer))
+    func `[integer] trailing us`() throws {
         try invalidate(pathComponents: ["integer", "trailing-us"])
     }
 
-    @Test("[integer] trailing us bin", .tags(.integer))
-    func integer__trailing_us_bin() throws {
+    @Test(.tags(.integer))
+    func `[integer] trailing us bin`() throws {
         try invalidate(pathComponents: ["integer", "trailing-us-bin"])
     }
 
-    @Test("[integer] trailing us hex", .tags(.integer))
-    func integer__trailing_us_hex() throws {
+    @Test(.tags(.integer))
+    func `[integer] trailing us hex`() throws {
         try invalidate(pathComponents: ["integer", "trailing-us-hex"])
     }
 
-    @Test("[integer] trailing us oct", .tags(.integer))
-    func integer__trailing_us_oct() throws {
+    @Test(.tags(.integer))
+    func `[integer] trailing us oct`() throws {
         try invalidate(pathComponents: ["integer", "trailing-us-oct"])
     }
 
-    @Test("[integer] us after bin", .tags(.integer))
-    func integer__us_after_bin() throws {
+    @Test(.tags(.integer))
+    func `[integer] us after bin`() throws {
         try invalidate(pathComponents: ["integer", "us-after-bin"])
     }
 
-    @Test("[integer] us after hex", .tags(.integer))
-    func integer__us_after_hex() throws {
+    @Test(.tags(.integer))
+    func `[integer] us after hex`() throws {
         try invalidate(pathComponents: ["integer", "us-after-hex"])
     }
 
-    @Test("[integer] us after oct", .tags(.integer))
-    func integer__us_after_oct() throws {
+    @Test(.tags(.integer))
+    func `[integer] us after oct`() throws {
         try invalidate(pathComponents: ["integer", "us-after-oct"])
     }
 
-    @Test("[key] after array", .tags(.key))
-    func key__after_array() throws {
+    @Test(.tags(.key))
+    func `[key] after array`() throws {
         try invalidate(pathComponents: ["key", "after-array"])
     }
 
-    @Test("[key] after table", .tags(.key))
-    func key__after_table() throws {
+    @Test(.tags(.key))
+    func `[key] after table`() throws {
         try invalidate(pathComponents: ["key", "after-table"])
     }
 
-    @Test("[key] after value", .tags(.key))
-    func key__after_value() throws {
+    @Test(.tags(.key))
+    func `[key] after value`() throws {
         try invalidate(pathComponents: ["key", "after-value"])
     }
 
-    @Test("[key] bare invalid character 01", .tags(.key))
-    func key__bare_invalid_character_01() throws {
+    @Test(.tags(.key))
+    func `[key] bare invalid character 01`() throws {
         try invalidate(pathComponents: ["key", "bare-invalid-character-01"])
     }
 
-    @Test("[key] bare invalid character 02", .tags(.key))
-    func key__bare_invalid_character_02() throws {
+    @Test(.tags(.key))
+    func `[key] bare invalid character 02`() throws {
         try invalidate(pathComponents: ["key", "bare-invalid-character-02"])
     }
 
-    @Test("[key] dot", .tags(.key))
-    func key__dot() throws {
+    @Test(.tags(.key))
+    func `[key] dot`() throws {
         try invalidate(pathComponents: ["key", "dot"])
     }
 
-    @Test("[key] dotdot", .tags(.key))
-    func key__dotdot() throws {
+    @Test(.tags(.key))
+    func `[key] dotdot`() throws {
         try invalidate(pathComponents: ["key", "dotdot"])
     }
 
-    @Test("[key] dotted redefine table 01", .tags(.key))
-    func key__dotted_redefine_table_01() throws {
+    @Test(.tags(.key))
+    func `[key] dotted redefine table 01`() throws {
         try invalidate(pathComponents: ["key", "dotted-redefine-table-01"])
     }
 
-    @Test("[key] dotted redefine table 02", .tags(.key))
-    func key__dotted_redefine_table_02() throws {
+    @Test(.tags(.key))
+    func `[key] dotted redefine table 02`() throws {
         try invalidate(pathComponents: ["key", "dotted-redefine-table-02"])
     }
 
-    @Test("[key] duplicate keys 01", .tags(.key))
-    func key__duplicate_keys_01() throws {
+    @Test(.tags(.key))
+    func `[key] duplicate keys 01`() throws {
         try invalidate(pathComponents: ["key", "duplicate-keys-01"])
     }
 
-    @Test("[key] duplicate keys 02", .tags(.key))
-    func key__duplicate_keys_02() throws {
+    @Test(.tags(.key))
+    func `[key] duplicate keys 02`() throws {
         try invalidate(pathComponents: ["key", "duplicate-keys-02"])
     }
 
-    @Test("[key] duplicate keys 03", .tags(.key))
-    func key__duplicate_keys_03() throws {
+    @Test(.tags(.key))
+    func `[key] duplicate keys 03`() throws {
         try invalidate(pathComponents: ["key", "duplicate-keys-03"])
     }
 
-    @Test("[key] duplicate keys 04", .tags(.key))
-    func key__duplicate_keys_04() throws {
+    @Test(.tags(.key))
+    func `[key] duplicate keys 04`() throws {
         try invalidate(pathComponents: ["key", "duplicate-keys-04"])
     }
 
-    @Test("[key] duplicate keys 05", .tags(.key))
-    func key__duplicate_keys_05() throws {
+    @Test(.tags(.key))
+    func `[key] duplicate keys 05`() throws {
         try invalidate(pathComponents: ["key", "duplicate-keys-05"])
     }
 
-    @Test("[key] duplicate keys 06", .tags(.key))
-    func key__duplicate_keys_06() throws {
+    @Test(.tags(.key))
+    func `[key] duplicate keys 06`() throws {
         try invalidate(pathComponents: ["key", "duplicate-keys-06"])
     }
 
-    @Test("[key] duplicate keys 07", .tags(.key))
-    func key__duplicate_keys_07() throws {
+    @Test(.tags(.key))
+    func `[key] duplicate keys 07`() throws {
         try invalidate(pathComponents: ["key", "duplicate-keys-07"])
     }
 
-    @Test("[key] duplicate keys 08", .tags(.key))
-    func key__duplicate_keys_08() throws {
+    @Test(.tags(.key))
+    func `[key] duplicate keys 08`() throws {
         try invalidate(pathComponents: ["key", "duplicate-keys-08"])
     }
 
-    @Test("[key] duplicate keys 09", .tags(.key))
-    func key__duplicate_keys_09() throws {
+    @Test(.tags(.key))
+    func `[key] duplicate keys 09`() throws {
         try invalidate(pathComponents: ["key", "duplicate-keys-09"])
     }
 
-    @Test("[key] empty", .tags(.key))
-    func key__empty() throws {
+    @Test(.tags(.key))
+    func `[key] empty`() throws {
         try invalidate(pathComponents: ["key", "empty"])
     }
 
-    @Test("[key] end in escape", .tags(.key))
-    func key__end_in_escape() throws {
+    @Test(.tags(.key))
+    func `[key] end in escape`() throws {
         try invalidate(pathComponents: ["key", "end-in-escape"])
     }
 
-    @Test("[key] escape", .tags(.key))
-    func key__escape() throws {
+    @Test(.tags(.key))
+    func `[key] escape`() throws {
         try invalidate(pathComponents: ["key", "escape"])
     }
 
-    @Test("[key] hash", .tags(.key))
-    func key__hash() throws {
+    @Test(.tags(.key))
+    func `[key] hash`() throws {
         try invalidate(pathComponents: ["key", "hash"])
     }
 
-    @Test("[key] multiline key 01", .tags(.key))
-    func key__multiline_key_01() throws {
+    @Test(.tags(.key))
+    func `[key] multiline key 01`() throws {
         try invalidate(pathComponents: ["key", "multiline-key-01"])
     }
 
-    @Test("[key] multiline key 02", .tags(.key))
-    func key__multiline_key_02() throws {
+    @Test(.tags(.key))
+    func `[key] multiline key 02`() throws {
         try invalidate(pathComponents: ["key", "multiline-key-02"])
     }
 
-    @Test("[key] multiline key 03", .tags(.key))
-    func key__multiline_key_03() throws {
+    @Test(.tags(.key))
+    func `[key] multiline key 03`() throws {
         try invalidate(pathComponents: ["key", "multiline-key-03"])
     }
 
-    @Test("[key] multiline key 04", .tags(.key))
-    func key__multiline_key_04() throws {
+    @Test(.tags(.key))
+    func `[key] multiline key 04`() throws {
         try invalidate(pathComponents: ["key", "multiline-key-04"])
     }
 
-    @Test("[key] newline 01", .tags(.key))
-    func key__newline_01() throws {
+    @Test(.tags(.key))
+    func `[key] newline 01`() throws {
         try invalidate(pathComponents: ["key", "newline-01"])
     }
 
-    @Test("[key] newline 02", .tags(.key))
-    func key__newline_02() throws {
+    @Test(.tags(.key))
+    func `[key] newline 02`() throws {
         try invalidate(pathComponents: ["key", "newline-02"])
     }
 
-    @Test("[key] newline 03", .tags(.key))
-    func key__newline_03() throws {
+    @Test(.tags(.key))
+    func `[key] newline 03`() throws {
         try invalidate(pathComponents: ["key", "newline-03"])
     }
 
-    @Test("[key] newline 04", .tags(.key))
-    func key__newline_04() throws {
+    @Test(.tags(.key))
+    func `[key] newline 04`() throws {
         try invalidate(pathComponents: ["key", "newline-04"])
     }
 
-    @Test("[key] newline 05", .tags(.key))
-    func key__newline_05() throws {
+    @Test(.tags(.key))
+    func `[key] newline 05`() throws {
         try invalidate(pathComponents: ["key", "newline-05"])
     }
 
-    @Test("[key] newline 06", .tags(.key))
-    func key__newline_06() throws {
+    @Test(.tags(.key))
+    func `[key] newline 06`() throws {
         try invalidate(pathComponents: ["key", "newline-06"])
     }
 
-    @Test("[key] no eol 01", .tags(.key))
-    func key__no_eol_01() throws {
+    @Test(.tags(.key))
+    func `[key] no eol 01`() throws {
         try invalidate(pathComponents: ["key", "no-eol-01"])
     }
 
-    @Test("[key] no eol 02", .tags(.key))
-    func key__no_eol_02() throws {
+    @Test(.tags(.key))
+    func `[key] no eol 02`() throws {
         try invalidate(pathComponents: ["key", "no-eol-02"])
     }
 
-    @Test("[key] no eol 03", .tags(.key))
-    func key__no_eol_03() throws {
+    @Test(.tags(.key))
+    func `[key] no eol 03`() throws {
         try invalidate(pathComponents: ["key", "no-eol-03"])
     }
 
-    @Test("[key] no eol 04", .tags(.key))
-    func key__no_eol_04() throws {
+    @Test(.tags(.key))
+    func `[key] no eol 04`() throws {
         try invalidate(pathComponents: ["key", "no-eol-04"])
     }
 
-    @Test("[key] no eol 05", .tags(.key))
-    func key__no_eol_05() throws {
+    @Test(.tags(.key))
+    func `[key] no eol 05`() throws {
         try invalidate(pathComponents: ["key", "no-eol-05"])
     }
 
-    @Test("[key] no eol 06", .tags(.key))
-    func key__no_eol_06() throws {
+    @Test(.tags(.key))
+    func `[key] no eol 06`() throws {
         try invalidate(pathComponents: ["key", "no-eol-06"])
     }
 
-    @Test("[key] no eol 07", .tags(.key))
-    func key__no_eol_07() throws {
+    @Test(.tags(.key))
+    func `[key] no eol 07`() throws {
         try invalidate(pathComponents: ["key", "no-eol-07"])
     }
 
-    @Test("[key] only float", .tags(.key))
-    func key__only_float() throws {
+    @Test(.tags(.key))
+    func `[key] only float`() throws {
         try invalidate(pathComponents: ["key", "only-float"])
     }
 
-    @Test("[key] only int", .tags(.key))
-    func key__only_int() throws {
+    @Test(.tags(.key))
+    func `[key] only int`() throws {
         try invalidate(pathComponents: ["key", "only-int"])
     }
 
-    @Test("[key] only str", .tags(.key))
-    func key__only_str() throws {
+    @Test(.tags(.key))
+    func `[key] only str`() throws {
         try invalidate(pathComponents: ["key", "only-str"])
     }
 
-    @Test("[key] open bracket", .tags(.key))
-    func key__open_bracket() throws {
+    @Test(.tags(.key))
+    func `[key] open bracket`() throws {
         try invalidate(pathComponents: ["key", "open-bracket"])
     }
 
-    @Test("[key] partial quoted", .tags(.key))
-    func key__partial_quoted() throws {
+    @Test(.tags(.key))
+    func `[key] partial quoted`() throws {
         try invalidate(pathComponents: ["key", "partial-quoted"])
     }
 
-    @Test("[key] quoted unclosed 01", .tags(.key))
-    func key__quoted_unclosed_01() throws {
+    @Test(.tags(.key))
+    func `[key] quoted unclosed 01`() throws {
         try invalidate(pathComponents: ["key", "quoted-unclosed-01"])
     }
 
-    @Test("[key] quoted unclosed 02", .tags(.key))
-    func key__quoted_unclosed_02() throws {
+    @Test(.tags(.key))
+    func `[key] quoted unclosed 02`() throws {
         try invalidate(pathComponents: ["key", "quoted-unclosed-02"])
     }
 
-    @Test("[key] single open bracket", .tags(.key))
-    func key__single_open_bracket() throws {
+    @Test(.tags(.key))
+    func `[key] single open bracket`() throws {
         try invalidate(pathComponents: ["key", "single-open-bracket"])
     }
 
-    @Test("[key] space", .tags(.key))
-    func key__space() throws {
+    @Test(.tags(.key))
+    func `[key] space`() throws {
         try invalidate(pathComponents: ["key", "space"])
     }
 
-    @Test("[key] special character", .tags(.key))
-    func key__special_character() throws {
+    @Test(.tags(.key))
+    func `[key] special character`() throws {
         try invalidate(pathComponents: ["key", "special-character"])
     }
 
-    @Test("[key] start bracket", .tags(.key))
-    func key__start_bracket() throws {
+    @Test(.tags(.key))
+    func `[key] start bracket`() throws {
         try invalidate(pathComponents: ["key", "start-bracket"])
     }
 
-    @Test("[key] start dot", .tags(.key))
-    func key__start_dot() throws {
+    @Test(.tags(.key))
+    func `[key] start dot`() throws {
         try invalidate(pathComponents: ["key", "start-dot"])
     }
 
-    @Test("[key] two equals 01", .tags(.key))
-    func key__two_equals_01() throws {
+    @Test(.tags(.key))
+    func `[key] two equals 01`() throws {
         try invalidate(pathComponents: ["key", "two-equals-01"])
     }
 
-    @Test("[key] two equals 02", .tags(.key))
-    func key__two_equals_02() throws {
+    @Test(.tags(.key))
+    func `[key] two equals 02`() throws {
         try invalidate(pathComponents: ["key", "two-equals-02"])
     }
 
-    @Test("[key] two equals 03", .tags(.key))
-    func key__two_equals_03() throws {
+    @Test(.tags(.key))
+    func `[key] two equals 03`() throws {
         try invalidate(pathComponents: ["key", "two-equals-03"])
     }
 
-    @Test("[key] without value 01", .tags(.key))
-    func key__without_value_01() throws {
+    @Test(.tags(.key))
+    func `[key] without value 01`() throws {
         try invalidate(pathComponents: ["key", "without-value-01"])
     }
 
-    @Test("[key] without value 02", .tags(.key))
-    func key__without_value_02() throws {
+    @Test(.tags(.key))
+    func `[key] without value 02`() throws {
         try invalidate(pathComponents: ["key", "without-value-02"])
     }
 
-    @Test("[key] without value 03", .tags(.key))
-    func key__without_value_03() throws {
+    @Test(.tags(.key))
+    func `[key] without value 03`() throws {
         try invalidate(pathComponents: ["key", "without-value-03"])
     }
 
-    @Test("[key] without value 04", .tags(.key))
-    func key__without_value_04() throws {
+    @Test(.tags(.key))
+    func `[key] without value 04`() throws {
         try invalidate(pathComponents: ["key", "without-value-04"])
     }
 
-    @Test("[key] without value 05", .tags(.key))
-    func key__without_value_05() throws {
+    @Test(.tags(.key))
+    func `[key] without value 05`() throws {
         try invalidate(pathComponents: ["key", "without-value-05"])
     }
 
-    @Test("[key] without value 06", .tags(.key))
-    func key__without_value_06() throws {
+    @Test(.tags(.key))
+    func `[key] without value 06`() throws {
         try invalidate(pathComponents: ["key", "without-value-06"])
     }
 
-    @Test("[key] without value 07", .tags(.key))
-    func key__without_value_07() throws {
+    @Test(.tags(.key))
+    func `[key] without value 07`() throws {
         try invalidate(pathComponents: ["key", "without-value-07"])
     }
 
-    @Test("[local-date] day 1digit", .tags(.local_date))
-    func local_date__day_1digit() throws {
+    @Test(.tags(.local_date))
+    func `[local-date] day 1digit`() throws {
         try invalidate(pathComponents: ["local-date", "day-1digit"])
     }
 
-    @Test("[local-date] feb 29", .tags(.local_date))
-    func local_date__feb_29() throws {
+    @Test(.tags(.local_date))
+    func `[local-date] feb 29`() throws {
         try invalidate(pathComponents: ["local-date", "feb-29"])
     }
 
-    @Test("[local-date] feb 30", .tags(.local_date))
-    func local_date__feb_30() throws {
+    @Test(.tags(.local_date))
+    func `[local-date] feb 30`() throws {
         try invalidate(pathComponents: ["local-date", "feb-30"])
     }
 
-    @Test("[local-date] mday over", .tags(.local_date))
-    func local_date__mday_over() throws {
+    @Test(.tags(.local_date))
+    func `[local-date] mday over`() throws {
         try invalidate(pathComponents: ["local-date", "mday-over"])
     }
 
-    @Test("[local-date] mday under", .tags(.local_date))
-    func local_date__mday_under() throws {
+    @Test(.tags(.local_date))
+    func `[local-date] mday under`() throws {
         try invalidate(pathComponents: ["local-date", "mday-under"])
     }
 
-    @Test("[local-date] month over", .tags(.local_date))
-    func local_date__month_over() throws {
+    @Test(.tags(.local_date))
+    func `[local-date] month over`() throws {
         try invalidate(pathComponents: ["local-date", "month-over"])
     }
 
-    @Test("[local-date] month under", .tags(.local_date))
-    func local_date__month_under() throws {
+    @Test(.tags(.local_date))
+    func `[local-date] month under`() throws {
         try invalidate(pathComponents: ["local-date", "month-under"])
     }
 
-    @Test("[local-date] no leads", .tags(.local_date))
-    func local_date__no_leads() throws {
+    @Test(.tags(.local_date))
+    func `[local-date] no leads`() throws {
         try invalidate(pathComponents: ["local-date", "no-leads"])
     }
 
-    @Test("[local-date] no leads with milli", .tags(.local_date))
-    func local_date__no_leads_with_milli() throws {
+    @Test(.tags(.local_date))
+    func `[local-date] no leads with milli`() throws {
         try invalidate(pathComponents: ["local-date", "no-leads-with-milli"])
     }
 
-    @Test("[local-date] trailing t", .tags(.local_date))
-    func local_date__trailing_t() throws {
+    @Test(.tags(.local_date))
+    func `[local-date] trailing t`() throws {
         try invalidate(pathComponents: ["local-date", "trailing-t"])
     }
 
-    @Test("[local-date] y10k", .tags(.local_date))
-    func local_date__y10k() throws {
+    @Test(.tags(.local_date))
+    func `[local-date] y10k`() throws {
         try invalidate(pathComponents: ["local-date", "y10k"])
     }
 
-    @Test("[local-date] year 3digits", .tags(.local_date))
-    func local_date__year_3digits() throws {
+    @Test(.tags(.local_date))
+    func `[local-date] year 3digits`() throws {
         try invalidate(pathComponents: ["local-date", "year-3digits"])
     }
 
-    @Test("[local-datetime] feb 29", .tags(.local_datetime))
-    func local_datetime__feb_29() throws {
+    @Test(.tags(.local_datetime))
+    func `[local-datetime] feb 29`() throws {
         try invalidate(pathComponents: ["local-datetime", "feb-29"])
     }
 
-    @Test("[local-datetime] feb 30", .tags(.local_datetime))
-    func local_datetime__feb_30() throws {
+    @Test(.tags(.local_datetime))
+    func `[local-datetime] feb 30`() throws {
         try invalidate(pathComponents: ["local-datetime", "feb-30"])
     }
 
-    @Test("[local-datetime] hour over", .tags(.local_datetime))
-    func local_datetime__hour_over() throws {
+    @Test(.tags(.local_datetime))
+    func `[local-datetime] hour over`() throws {
         try invalidate(pathComponents: ["local-datetime", "hour-over"])
     }
 
-    @Test("[local-datetime] mday over", .tags(.local_datetime))
-    func local_datetime__mday_over() throws {
+    @Test(.tags(.local_datetime))
+    func `[local-datetime] mday over`() throws {
         try invalidate(pathComponents: ["local-datetime", "mday-over"])
     }
 
-    @Test("[local-datetime] mday under", .tags(.local_datetime))
-    func local_datetime__mday_under() throws {
+    @Test(.tags(.local_datetime))
+    func `[local-datetime] mday under`() throws {
         try invalidate(pathComponents: ["local-datetime", "mday-under"])
     }
 
-    @Test("[local-datetime] minute over", .tags(.local_datetime))
-    func local_datetime__minute_over() throws {
+    @Test(.tags(.local_datetime))
+    func `[local-datetime] minute over`() throws {
         try invalidate(pathComponents: ["local-datetime", "minute-over"])
     }
 
-    @Test("[local-datetime] month over", .tags(.local_datetime))
-    func local_datetime__month_over() throws {
+    @Test(.tags(.local_datetime))
+    func `[local-datetime] month over`() throws {
         try invalidate(pathComponents: ["local-datetime", "month-over"])
     }
 
-    @Test("[local-datetime] month under", .tags(.local_datetime))
-    func local_datetime__month_under() throws {
+    @Test(.tags(.local_datetime))
+    func `[local-datetime] month under`() throws {
         try invalidate(pathComponents: ["local-datetime", "month-under"])
     }
 
-    @Test("[local-datetime] no leads", .tags(.local_datetime))
-    func local_datetime__no_leads() throws {
+    @Test(.tags(.local_datetime))
+    func `[local-datetime] no leads`() throws {
         try invalidate(pathComponents: ["local-datetime", "no-leads"])
     }
 
-    @Test("[local-datetime] no leads with milli", .tags(.local_datetime))
-    func local_datetime__no_leads_with_milli() throws {
+    @Test(.tags(.local_datetime))
+    func `[local-datetime] no leads with milli`() throws {
         try invalidate(pathComponents: ["local-datetime", "no-leads-with-milli"])
     }
 
-    @Test("[local-datetime] no t", .tags(.local_datetime))
-    func local_datetime__no_t() throws {
+    @Test(.tags(.local_datetime))
+    func `[local-datetime] no t`() throws {
         try invalidate(pathComponents: ["local-datetime", "no-t"])
     }
 
-    @Test("[local-datetime] second over", .tags(.local_datetime))
-    func local_datetime__second_over() throws {
+    @Test(.tags(.local_datetime))
+    func `[local-datetime] second over`() throws {
         try invalidate(pathComponents: ["local-datetime", "second-over"])
     }
 
-    @Test("[local-datetime] time no leads", .tags(.local_datetime))
-    func local_datetime__time_no_leads() throws {
+    @Test(.tags(.local_datetime))
+    func `[local-datetime] time no leads`() throws {
         try invalidate(pathComponents: ["local-datetime", "time-no-leads"])
     }
 
-    @Test("[local-datetime] y10k", .tags(.local_datetime))
-    func local_datetime__y10k() throws {
+    @Test(.tags(.local_datetime))
+    func `[local-datetime] y10k`() throws {
         try invalidate(pathComponents: ["local-datetime", "y10k"])
     }
 
-    @Test("[local-time] hour over", .tags(.local_time))
-    func local_time__hour_over() throws {
+    @Test(.tags(.local_time))
+    func `[local-time] hour over`() throws {
         try invalidate(pathComponents: ["local-time", "hour-over"])
     }
 
-    @Test("[local-time] minute over", .tags(.local_time))
-    func local_time__minute_over() throws {
+    @Test(.tags(.local_time))
+    func `[local-time] minute over`() throws {
         try invalidate(pathComponents: ["local-time", "minute-over"])
     }
 
-    @Test("[local-time] second over", .tags(.local_time))
-    func local_time__second_over() throws {
+    @Test(.tags(.local_time))
+    func `[local-time] second over`() throws {
         try invalidate(pathComponents: ["local-time", "second-over"])
     }
 
-    @Test("[local-time] time no leads 01", .tags(.local_time))
-    func local_time__time_no_leads_01() throws {
+    @Test(.tags(.local_time))
+    func `[local-time] time no leads 01`() throws {
         try invalidate(pathComponents: ["local-time", "time-no-leads-01"])
     }
 
-    @Test("[local-time] time no leads 02", .tags(.local_time))
-    func local_time__time_no_leads_02() throws {
+    @Test(.tags(.local_time))
+    func `[local-time] time no leads 02`() throws {
         try invalidate(pathComponents: ["local-time", "time-no-leads-02"])
     }
 
-    @Test("[local-time] trailing dot", .tags(.local_time))
-    func local_time__trailing_dot() throws {
+    @Test(.tags(.local_time))
+    func `[local-time] trailing dot`() throws {
         try invalidate(pathComponents: ["local-time", "trailing-dot"])
     }
 
-    @Test("[local-time] trailing dotdot", .tags(.local_time))
-    func local_time__trailing_dotdot() throws {
+    @Test(.tags(.local_time))
+    func `[local-time] trailing dotdot`() throws {
         try invalidate(pathComponents: ["local-time", "trailing-dotdot"])
     }
 
-    @Test("[spec-1.1.0] common 16 0", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_16_0() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 16 0`() throws {
         try invalidate(pathComponents: ["spec-1.1.0", "common-16-0"])
     }
 
-    @Test("[spec-1.1.0] common 19 0", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_19_0() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 19 0`() throws {
         try invalidate(pathComponents: ["spec-1.1.0", "common-19-0"])
     }
 
-    @Test("[spec-1.1.0] common 2", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_2() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 2`() throws {
         try invalidate(pathComponents: ["spec-1.1.0", "common-2"])
     }
 
-    @Test("[spec-1.1.0] common 46 0", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_46_0() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 46 0`() throws {
         try invalidate(pathComponents: ["spec-1.1.0", "common-46-0"])
     }
 
-    @Test("[spec-1.1.0] common 46 1", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_46_1() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 46 1`() throws {
         try invalidate(pathComponents: ["spec-1.1.0", "common-46-1"])
     }
 
-    @Test("[spec-1.1.0] common 49 0", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_49_0() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 49 0`() throws {
         try invalidate(pathComponents: ["spec-1.1.0", "common-49-0"])
     }
 
-    @Test("[spec-1.1.0] common 5", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_5() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 5`() throws {
         try invalidate(pathComponents: ["spec-1.1.0", "common-5"])
     }
 
-    @Test("[spec-1.1.0] common 50 0", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_50_0() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 50 0`() throws {
         try invalidate(pathComponents: ["spec-1.1.0", "common-50-0"])
     }
 
-    @Test("[string] bad byte escape", .tags(.string))
-    func string__bad_byte_escape() throws {
+    @Test(.tags(.string))
+    func `[string] bad byte escape`() throws {
         try invalidate(pathComponents: ["string", "bad-byte-escape"])
     }
 
-    @Test("[string] bad concat", .tags(.string))
-    func string__bad_concat() throws {
+    @Test(.tags(.string))
+    func `[string] bad concat`() throws {
         try invalidate(pathComponents: ["string", "bad-concat"])
     }
 
-    @Test("[string] bad escape 01", .tags(.string))
-    func string__bad_escape_01() throws {
+    @Test(.tags(.string))
+    func `[string] bad escape 01`() throws {
         try invalidate(pathComponents: ["string", "bad-escape-01"])
     }
 
-    @Test("[string] bad escape 02", .tags(.string))
-    func string__bad_escape_02() throws {
+    @Test(.tags(.string))
+    func `[string] bad escape 02`() throws {
         try invalidate(pathComponents: ["string", "bad-escape-02"])
     }
 
-    @Test("[string] bad escape 03", .tags(.string))
-    func string__bad_escape_03() throws {
+    @Test(.tags(.string))
+    func `[string] bad escape 03`() throws {
         try invalidate(pathComponents: ["string", "bad-escape-03"])
     }
 
-    @Test("[string] bad escape 04", .tags(.string))
-    func string__bad_escape_04() throws {
+    @Test(.tags(.string))
+    func `[string] bad escape 04`() throws {
         try invalidate(pathComponents: ["string", "bad-escape-04"])
     }
 
-    @Test("[string] bad escape 05", .tags(.string))
-    func string__bad_escape_05() throws {
+    @Test(.tags(.string))
+    func `[string] bad escape 05`() throws {
         try invalidate(pathComponents: ["string", "bad-escape-05"])
     }
 
-    @Test("[string] bad hex esc 01", .tags(.string))
-    func string__bad_hex_esc_01() throws {
+    @Test(.tags(.string))
+    func `[string] bad hex esc 01`() throws {
         try invalidate(pathComponents: ["string", "bad-hex-esc-01"])
     }
 
-    @Test("[string] bad hex esc 02", .tags(.string))
-    func string__bad_hex_esc_02() throws {
+    @Test(.tags(.string))
+    func `[string] bad hex esc 02`() throws {
         try invalidate(pathComponents: ["string", "bad-hex-esc-02"])
     }
 
-    @Test("[string] bad hex esc 03", .tags(.string))
-    func string__bad_hex_esc_03() throws {
+    @Test(.tags(.string))
+    func `[string] bad hex esc 03`() throws {
         try invalidate(pathComponents: ["string", "bad-hex-esc-03"])
     }
 
-    @Test("[string] bad hex esc 04", .tags(.string))
-    func string__bad_hex_esc_04() throws {
+    @Test(.tags(.string))
+    func `[string] bad hex esc 04`() throws {
         try invalidate(pathComponents: ["string", "bad-hex-esc-04"])
     }
 
-    @Test("[string] bad hex esc 05", .tags(.string))
-    func string__bad_hex_esc_05() throws {
+    @Test(.tags(.string))
+    func `[string] bad hex esc 05`() throws {
         try invalidate(pathComponents: ["string", "bad-hex-esc-05"])
     }
 
-    @Test("[string] bad multiline", .tags(.string))
-    func string__bad_multiline() throws {
+    @Test(.tags(.string))
+    func `[string] bad multiline`() throws {
         try invalidate(pathComponents: ["string", "bad-multiline"])
     }
 
-    @Test("[string] bad slash escape", .tags(.string))
-    func string__bad_slash_escape() throws {
+    @Test(.tags(.string))
+    func `[string] bad slash escape`() throws {
         try invalidate(pathComponents: ["string", "bad-slash-escape"])
     }
 
-    @Test("[string] bad uni esc 01", .tags(.string))
-    func string__bad_uni_esc_01() throws {
+    @Test(.tags(.string))
+    func `[string] bad uni esc 01`() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-01"])
     }
 
-    @Test("[string] bad uni esc 02", .tags(.string))
-    func string__bad_uni_esc_02() throws {
+    @Test(.tags(.string))
+    func `[string] bad uni esc 02`() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-02"])
     }
 
-    @Test("[string] bad uni esc 03", .tags(.string))
-    func string__bad_uni_esc_03() throws {
+    @Test(.tags(.string))
+    func `[string] bad uni esc 03`() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-03"])
     }
 
-    @Test("[string] bad uni esc 04", .tags(.string))
-    func string__bad_uni_esc_04() throws {
+    @Test(.tags(.string))
+    func `[string] bad uni esc 04`() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-04"])
     }
 
-    @Test("[string] bad uni esc 05", .tags(.string))
-    func string__bad_uni_esc_05() throws {
+    @Test(.tags(.string))
+    func `[string] bad uni esc 05`() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-05"])
     }
 
-    @Test("[string] bad uni esc 06", .tags(.string))
-    func string__bad_uni_esc_06() throws {
+    @Test(.tags(.string))
+    func `[string] bad uni esc 06`() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-06"])
     }
 
-    @Test("[string] bad uni esc 07", .tags(.string))
-    func string__bad_uni_esc_07() throws {
+    @Test(.tags(.string))
+    func `[string] bad uni esc 07`() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-07"])
     }
 
-    @Test("[string] bad uni esc ml 01", .tags(.string))
-    func string__bad_uni_esc_ml_01() throws {
+    @Test(.tags(.string))
+    func `[string] bad uni esc ml 01`() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-ml-01"])
     }
 
-    @Test("[string] bad uni esc ml 02", .tags(.string))
-    func string__bad_uni_esc_ml_02() throws {
+    @Test(.tags(.string))
+    func `[string] bad uni esc ml 02`() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-ml-02"])
     }
 
-    @Test("[string] bad uni esc ml 03", .tags(.string))
-    func string__bad_uni_esc_ml_03() throws {
+    @Test(.tags(.string))
+    func `[string] bad uni esc ml 03`() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-ml-03"])
     }
 
-    @Test("[string] bad uni esc ml 04", .tags(.string))
-    func string__bad_uni_esc_ml_04() throws {
+    @Test(.tags(.string))
+    func `[string] bad uni esc ml 04`() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-ml-04"])
     }
 
-    @Test("[string] bad uni esc ml 05", .tags(.string))
-    func string__bad_uni_esc_ml_05() throws {
+    @Test(.tags(.string))
+    func `[string] bad uni esc ml 05`() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-ml-05"])
     }
 
-    @Test("[string] bad uni esc ml 06", .tags(.string))
-    func string__bad_uni_esc_ml_06() throws {
+    @Test(.tags(.string))
+    func `[string] bad uni esc ml 06`() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-ml-06"])
     }
 
-    @Test("[string] bad uni esc ml 07", .tags(.string))
-    func string__bad_uni_esc_ml_07() throws {
+    @Test(.tags(.string))
+    func `[string] bad uni esc ml 07`() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-ml-07"])
     }
 
-    @Test("[string] basic multiline out of range unicode escape 01", .tags(.string))
-    func string__basic_multiline_out_of_range_unicode_escape_01() throws {
+    @Test(.tags(.string))
+    func `[string] basic multiline out of range unicode escape 01`() throws {
         try invalidate(pathComponents: ["string", "basic-multiline-out-of-range-unicode-escape-01"])
     }
 
-    @Test("[string] basic multiline out of range unicode escape 02", .tags(.string))
-    func string__basic_multiline_out_of_range_unicode_escape_02() throws {
+    @Test(.tags(.string))
+    func `[string] basic multiline out of range unicode escape 02`() throws {
         try invalidate(pathComponents: ["string", "basic-multiline-out-of-range-unicode-escape-02"])
     }
 
-    @Test("[string] basic multiline quotes", .tags(.string))
-    func string__basic_multiline_quotes() throws {
+    @Test(.tags(.string))
+    func `[string] basic multiline quotes`() throws {
         try invalidate(pathComponents: ["string", "basic-multiline-quotes"])
     }
 
-    @Test("[string] basic multiline unknown escape", .tags(.string))
-    func string__basic_multiline_unknown_escape() throws {
+    @Test(.tags(.string))
+    func `[string] basic multiline unknown escape`() throws {
         try invalidate(pathComponents: ["string", "basic-multiline-unknown-escape"])
     }
 
-    @Test("[string] basic out of range unicode escape 01", .tags(.string))
-    func string__basic_out_of_range_unicode_escape_01() throws {
+    @Test(.tags(.string))
+    func `[string] basic out of range unicode escape 01`() throws {
         try invalidate(pathComponents: ["string", "basic-out-of-range-unicode-escape-01"])
     }
 
-    @Test("[string] basic out of range unicode escape 02", .tags(.string))
-    func string__basic_out_of_range_unicode_escape_02() throws {
+    @Test(.tags(.string))
+    func `[string] basic out of range unicode escape 02`() throws {
         try invalidate(pathComponents: ["string", "basic-out-of-range-unicode-escape-02"])
     }
 
-    @Test("[string] basic unknown escape", .tags(.string))
-    func string__basic_unknown_escape() throws {
+    @Test(.tags(.string))
+    func `[string] basic unknown escape`() throws {
         try invalidate(pathComponents: ["string", "basic-unknown-escape"])
     }
 
-    @Test("[string] literal multiline quotes 01", .tags(.string))
-    func string__literal_multiline_quotes_01() throws {
+    @Test(.tags(.string))
+    func `[string] literal multiline quotes 01`() throws {
         try invalidate(pathComponents: ["string", "literal-multiline-quotes-01"])
     }
 
-    @Test("[string] literal multiline quotes 02", .tags(.string))
-    func string__literal_multiline_quotes_02() throws {
+    @Test(.tags(.string))
+    func `[string] literal multiline quotes 02`() throws {
         try invalidate(pathComponents: ["string", "literal-multiline-quotes-02"])
     }
 
-    @Test("[string] missing quotes", .tags(.string))
-    func string__missing_quotes() throws {
+    @Test(.tags(.string))
+    func `[string] missing quotes`() throws {
         try invalidate(pathComponents: ["string", "missing-quotes"])
     }
 
-    @Test("[string] missing quotes array", .tags(.string))
-    func string__missing_quotes_array() throws {
+    @Test(.tags(.string))
+    func `[string] missing quotes array`() throws {
         try invalidate(pathComponents: ["string", "missing-quotes-array"])
     }
 
-    @Test("[string] missing quotes inline table", .tags(.string))
-    func string__missing_quotes_inline_table() throws {
+    @Test(.tags(.string))
+    func `[string] missing quotes inline table`() throws {
         try invalidate(pathComponents: ["string", "missing-quotes-inline-table"])
     }
 
-    @Test("[string] multiline bad escape 01", .tags(.string))
-    func string__multiline_bad_escape_01() throws {
+    @Test(.tags(.string))
+    func `[string] multiline bad escape 01`() throws {
         try invalidate(pathComponents: ["string", "multiline-bad-escape-01"])
     }
 
-    @Test("[string] multiline bad escape 02", .tags(.string))
-    func string__multiline_bad_escape_02() throws {
+    @Test(.tags(.string))
+    func `[string] multiline bad escape 02`() throws {
         try invalidate(pathComponents: ["string", "multiline-bad-escape-02"])
     }
 
-    @Test("[string] multiline bad escape 03", .tags(.string))
-    func string__multiline_bad_escape_03() throws {
+    @Test(.tags(.string))
+    func `[string] multiline bad escape 03`() throws {
         try invalidate(pathComponents: ["string", "multiline-bad-escape-03"])
     }
 
-    @Test("[string] multiline bad escape 04", .tags(.string))
-    func string__multiline_bad_escape_04() throws {
+    @Test(.tags(.string))
+    func `[string] multiline bad escape 04`() throws {
         try invalidate(pathComponents: ["string", "multiline-bad-escape-04"])
     }
 
-    @Test("[string] multiline escape space 01", .tags(.string))
-    func string__multiline_escape_space_01() throws {
+    @Test(.tags(.string))
+    func `[string] multiline escape space 01`() throws {
         try invalidate(pathComponents: ["string", "multiline-escape-space-01"])
     }
 
-    @Test("[string] multiline escape space 02", .tags(.string))
-    func string__multiline_escape_space_02() throws {
+    @Test(.tags(.string))
+    func `[string] multiline escape space 02`() throws {
         try invalidate(pathComponents: ["string", "multiline-escape-space-02"])
     }
 
-    @Test("[string] multiline lit no close 01", .tags(.string))
-    func string__multiline_lit_no_close_01() throws {
+    @Test(.tags(.string))
+    func `[string] multiline lit no close 01`() throws {
         try invalidate(pathComponents: ["string", "multiline-lit-no-close-01"])
     }
 
-    @Test("[string] multiline lit no close 02", .tags(.string))
-    func string__multiline_lit_no_close_02() throws {
+    @Test(.tags(.string))
+    func `[string] multiline lit no close 02`() throws {
         try invalidate(pathComponents: ["string", "multiline-lit-no-close-02"])
     }
 
-    @Test("[string] multiline lit no close 03", .tags(.string))
-    func string__multiline_lit_no_close_03() throws {
+    @Test(.tags(.string))
+    func `[string] multiline lit no close 03`() throws {
         try invalidate(pathComponents: ["string", "multiline-lit-no-close-03"])
     }
 
-    @Test("[string] multiline lit no close 04", .tags(.string))
-    func string__multiline_lit_no_close_04() throws {
+    @Test(.tags(.string))
+    func `[string] multiline lit no close 04`() throws {
         try invalidate(pathComponents: ["string", "multiline-lit-no-close-04"])
     }
 
-    @Test("[string] multiline no close 01", .tags(.string))
-    func string__multiline_no_close_01() throws {
+    @Test(.tags(.string))
+    func `[string] multiline no close 01`() throws {
         try invalidate(pathComponents: ["string", "multiline-no-close-01"])
     }
 
-    @Test("[string] multiline no close 02", .tags(.string))
-    func string__multiline_no_close_02() throws {
+    @Test(.tags(.string))
+    func `[string] multiline no close 02`() throws {
         try invalidate(pathComponents: ["string", "multiline-no-close-02"])
     }
 
-    @Test("[string] multiline no close 03", .tags(.string))
-    func string__multiline_no_close_03() throws {
+    @Test(.tags(.string))
+    func `[string] multiline no close 03`() throws {
         try invalidate(pathComponents: ["string", "multiline-no-close-03"])
     }
 
-    @Test("[string] multiline no close 04", .tags(.string))
-    func string__multiline_no_close_04() throws {
+    @Test(.tags(.string))
+    func `[string] multiline no close 04`() throws {
         try invalidate(pathComponents: ["string", "multiline-no-close-04"])
     }
 
-    @Test("[string] multiline no close 05", .tags(.string))
-    func string__multiline_no_close_05() throws {
+    @Test(.tags(.string))
+    func `[string] multiline no close 05`() throws {
         try invalidate(pathComponents: ["string", "multiline-no-close-05"])
     }
 
-    @Test("[string] multiline quotes 01", .tags(.string))
-    func string__multiline_quotes_01() throws {
+    @Test(.tags(.string))
+    func `[string] multiline quotes 01`() throws {
         try invalidate(pathComponents: ["string", "multiline-quotes-01"])
     }
 
-    @Test("[string] no close 01", .tags(.string))
-    func string__no_close_01() throws {
+    @Test(.tags(.string))
+    func `[string] no close 01`() throws {
         try invalidate(pathComponents: ["string", "no-close-01"])
     }
 
-    @Test("[string] no close 02", .tags(.string))
-    func string__no_close_02() throws {
+    @Test(.tags(.string))
+    func `[string] no close 02`() throws {
         try invalidate(pathComponents: ["string", "no-close-02"])
     }
 
-    @Test("[string] no close 03", .tags(.string))
-    func string__no_close_03() throws {
+    @Test(.tags(.string))
+    func `[string] no close 03`() throws {
         try invalidate(pathComponents: ["string", "no-close-03"])
     }
 
-    @Test("[string] no close 04", .tags(.string))
-    func string__no_close_04() throws {
+    @Test(.tags(.string))
+    func `[string] no close 04`() throws {
         try invalidate(pathComponents: ["string", "no-close-04"])
     }
 
-    @Test("[string] no close 05", .tags(.string))
-    func string__no_close_05() throws {
+    @Test(.tags(.string))
+    func `[string] no close 05`() throws {
         try invalidate(pathComponents: ["string", "no-close-05"])
     }
 
-    @Test("[string] no close 06", .tags(.string))
-    func string__no_close_06() throws {
+    @Test(.tags(.string))
+    func `[string] no close 06`() throws {
         try invalidate(pathComponents: ["string", "no-close-06"])
     }
 
-    @Test("[string] no close 07", .tags(.string))
-    func string__no_close_07() throws {
+    @Test(.tags(.string))
+    func `[string] no close 07`() throws {
         try invalidate(pathComponents: ["string", "no-close-07"])
     }
 
-    @Test("[string] no close 08", .tags(.string))
-    func string__no_close_08() throws {
+    @Test(.tags(.string))
+    func `[string] no close 08`() throws {
         try invalidate(pathComponents: ["string", "no-close-08"])
     }
 
-    @Test("[string] no close 09", .tags(.string))
-    func string__no_close_09() throws {
+    @Test(.tags(.string))
+    func `[string] no close 09`() throws {
         try invalidate(pathComponents: ["string", "no-close-09"])
     }
 
-    @Test("[string] no close 10", .tags(.string))
-    func string__no_close_10() throws {
+    @Test(.tags(.string))
+    func `[string] no close 10`() throws {
         try invalidate(pathComponents: ["string", "no-close-10"])
     }
 
-    @Test("[string] no open 01", .tags(.string))
-    func string__no_open_01() throws {
+    @Test(.tags(.string))
+    func `[string] no open 01`() throws {
         try invalidate(pathComponents: ["string", "no-open-01"])
     }
 
-    @Test("[string] no open 02", .tags(.string))
-    func string__no_open_02() throws {
+    @Test(.tags(.string))
+    func `[string] no open 02`() throws {
         try invalidate(pathComponents: ["string", "no-open-02"])
     }
 
-    @Test("[string] no open 03", .tags(.string))
-    func string__no_open_03() throws {
+    @Test(.tags(.string))
+    func `[string] no open 03`() throws {
         try invalidate(pathComponents: ["string", "no-open-03"])
     }
 
-    @Test("[string] no open 04", .tags(.string))
-    func string__no_open_04() throws {
+    @Test(.tags(.string))
+    func `[string] no open 04`() throws {
         try invalidate(pathComponents: ["string", "no-open-04"])
     }
 
-    @Test("[string] no open 05", .tags(.string))
-    func string__no_open_05() throws {
+    @Test(.tags(.string))
+    func `[string] no open 05`() throws {
         try invalidate(pathComponents: ["string", "no-open-05"])
     }
 
-    @Test("[string] no open 06", .tags(.string))
-    func string__no_open_06() throws {
+    @Test(.tags(.string))
+    func `[string] no open 06`() throws {
         try invalidate(pathComponents: ["string", "no-open-06"])
     }
 
-    @Test("[string] no open 07", .tags(.string))
-    func string__no_open_07() throws {
+    @Test(.tags(.string))
+    func `[string] no open 07`() throws {
         try invalidate(pathComponents: ["string", "no-open-07"])
     }
 
-    @Test("[string] no open 08", .tags(.string))
-    func string__no_open_08() throws {
+    @Test(.tags(.string))
+    func `[string] no open 08`() throws {
         try invalidate(pathComponents: ["string", "no-open-08"])
     }
 
-    @Test("[string] text after string", .tags(.string))
-    func string__text_after_string() throws {
+    @Test(.tags(.string))
+    func `[string] text after string`() throws {
         try invalidate(pathComponents: ["string", "text-after-string"])
     }
 
-    @Test("[string] wrong close", .tags(.string))
-    func string__wrong_close() throws {
+    @Test(.tags(.string))
+    func `[string] wrong close`() throws {
         try invalidate(pathComponents: ["string", "wrong-close"])
     }
 
-    @Test("[table] append with dotted keys 01", .tags(.table))
-    func table__append_with_dotted_keys_01() throws {
+    @Test(.tags(.table))
+    func `[table] append with dotted keys 01`() throws {
         try invalidate(pathComponents: ["table", "append-with-dotted-keys-01"])
     }
 
-    @Test("[table] append with dotted keys 02", .tags(.table))
-    func table__append_with_dotted_keys_02() throws {
+    @Test(.tags(.table))
+    func `[table] append with dotted keys 02`() throws {
         try invalidate(pathComponents: ["table", "append-with-dotted-keys-02"])
     }
 
-    @Test("[table] append with dotted keys 03", .tags(.table))
-    func table__append_with_dotted_keys_03() throws {
+    @Test(.tags(.table))
+    func `[table] append with dotted keys 03`() throws {
         try invalidate(pathComponents: ["table", "append-with-dotted-keys-03"])
     }
 
-    @Test("[table] append with dotted keys 04", .tags(.table))
-    func table__append_with_dotted_keys_04() throws {
+    @Test(.tags(.table))
+    func `[table] append with dotted keys 04`() throws {
         try invalidate(pathComponents: ["table", "append-with-dotted-keys-04"])
     }
 
-    @Test("[table] append with dotted keys 05", .tags(.table))
-    func table__append_with_dotted_keys_05() throws {
+    @Test(.tags(.table))
+    func `[table] append with dotted keys 05`() throws {
         try invalidate(pathComponents: ["table", "append-with-dotted-keys-05"])
     }
 
-    @Test("[table] append with dotted keys 06", .tags(.table))
-    func table__append_with_dotted_keys_06() throws {
+    @Test(.tags(.table))
+    func `[table] append with dotted keys 06`() throws {
         try invalidate(pathComponents: ["table", "append-with-dotted-keys-06"])
     }
 
-    @Test("[table] append with dotted keys 07", .tags(.table))
-    func table__append_with_dotted_keys_07() throws {
+    @Test(.tags(.table))
+    func `[table] append with dotted keys 07`() throws {
         try invalidate(pathComponents: ["table", "append-with-dotted-keys-07"])
     }
 
-    @Test("[table] array empty", .tags(.table))
-    func table__array_empty() throws {
+    @Test(.tags(.table))
+    func `[table] array empty`() throws {
         try invalidate(pathComponents: ["table", "array-empty"])
     }
 
-    @Test("[table] array implicit", .tags(.table))
-    func table__array_implicit() throws {
+    @Test(.tags(.table))
+    func `[table] array implicit`() throws {
         try invalidate(pathComponents: ["table", "array-implicit"])
     }
 
-    @Test("[table] array no close 01", .tags(.table))
-    func table__array_no_close_01() throws {
+    @Test(.tags(.table))
+    func `[table] array no close 01`() throws {
         try invalidate(pathComponents: ["table", "array-no-close-01"])
     }
 
-    @Test("[table] array no close 02", .tags(.table))
-    func table__array_no_close_02() throws {
+    @Test(.tags(.table))
+    func `[table] array no close 02`() throws {
         try invalidate(pathComponents: ["table", "array-no-close-02"])
     }
 
-    @Test("[table] array no close 03", .tags(.table))
-    func table__array_no_close_03() throws {
+    @Test(.tags(.table))
+    func `[table] array no close 03`() throws {
         try invalidate(pathComponents: ["table", "array-no-close-03"])
     }
 
-    @Test("[table] array no close 04", .tags(.table))
-    func table__array_no_close_04() throws {
+    @Test(.tags(.table))
+    func `[table] array no close 04`() throws {
         try invalidate(pathComponents: ["table", "array-no-close-04"])
     }
 
-    @Test("[table] bare invalid character 01", .tags(.table))
-    func table__bare_invalid_character_01() throws {
+    @Test(.tags(.table))
+    func `[table] bare invalid character 01`() throws {
         try invalidate(pathComponents: ["table", "bare-invalid-character-01"])
     }
 
-    @Test("[table] bare invalid character 02", .tags(.table))
-    func table__bare_invalid_character_02() throws {
+    @Test(.tags(.table))
+    func `[table] bare invalid character 02`() throws {
         try invalidate(pathComponents: ["table", "bare-invalid-character-02"])
     }
 
-    @Test("[table] dot", .tags(.table))
-    func table__dot() throws {
+    @Test(.tags(.table))
+    func `[table] dot`() throws {
         try invalidate(pathComponents: ["table", "dot"])
     }
 
-    @Test("[table] dotdot", .tags(.table))
-    func table__dotdot() throws {
+    @Test(.tags(.table))
+    func `[table] dotdot`() throws {
         try invalidate(pathComponents: ["table", "dotdot"])
     }
 
-    @Test("[table] duplicate key 01", .tags(.table))
-    func table__duplicate_key_01() throws {
+    @Test(.tags(.table))
+    func `[table] duplicate key 01`() throws {
         try invalidate(pathComponents: ["table", "duplicate-key-01"])
     }
 
-    @Test("[table] duplicate key 02", .tags(.table))
-    func table__duplicate_key_02() throws {
+    @Test(.tags(.table))
+    func `[table] duplicate key 02`() throws {
         try invalidate(pathComponents: ["table", "duplicate-key-02"])
     }
 
-    @Test("[table] duplicate key 03", .tags(.table))
-    func table__duplicate_key_03() throws {
+    @Test(.tags(.table))
+    func `[table] duplicate key 03`() throws {
         try invalidate(pathComponents: ["table", "duplicate-key-03"])
     }
 
-    @Test("[table] duplicate key 04", .tags(.table))
-    func table__duplicate_key_04() throws {
+    @Test(.tags(.table))
+    func `[table] duplicate key 04`() throws {
         try invalidate(pathComponents: ["table", "duplicate-key-04"])
     }
 
-    @Test("[table] duplicate key 05", .tags(.table))
-    func table__duplicate_key_05() throws {
+    @Test(.tags(.table))
+    func `[table] duplicate key 05`() throws {
         try invalidate(pathComponents: ["table", "duplicate-key-05"])
     }
 
-    @Test("[table] duplicate key 06", .tags(.table))
-    func table__duplicate_key_06() throws {
+    @Test(.tags(.table))
+    func `[table] duplicate key 06`() throws {
         try invalidate(pathComponents: ["table", "duplicate-key-06"])
     }
 
-    @Test("[table] duplicate key 07", .tags(.table))
-    func table__duplicate_key_07() throws {
+    @Test(.tags(.table))
+    func `[table] duplicate key 07`() throws {
         try invalidate(pathComponents: ["table", "duplicate-key-07"])
     }
 
-    @Test("[table] duplicate key 08", .tags(.table))
-    func table__duplicate_key_08() throws {
+    @Test(.tags(.table))
+    func `[table] duplicate key 08`() throws {
         try invalidate(pathComponents: ["table", "duplicate-key-08"])
     }
 
-    @Test("[table] duplicate key 09", .tags(.table))
-    func table__duplicate_key_09() throws {
+    @Test(.tags(.table))
+    func `[table] duplicate key 09`() throws {
         try invalidate(pathComponents: ["table", "duplicate-key-09"])
     }
 
-    @Test("[table] duplicate key 10", .tags(.table))
-    func table__duplicate_key_10() throws {
+    @Test(.tags(.table))
+    func `[table] duplicate key 10`() throws {
         try invalidate(pathComponents: ["table", "duplicate-key-10"])
     }
 
-    @Test("[table] empty", .tags(.table))
-    func table__empty() throws {
+    @Test(.tags(.table))
+    func `[table] empty`() throws {
         try invalidate(pathComponents: ["table", "empty"])
     }
 
-    @Test("[table] empty implicit table", .tags(.table))
-    func table__empty_implicit_table() throws {
+    @Test(.tags(.table))
+    func `[table] empty implicit table`() throws {
         try invalidate(pathComponents: ["table", "empty-implicit-table"])
     }
 
-    @Test("[table] equals sign", .tags(.table))
-    func table__equals_sign() throws {
+    @Test(.tags(.table))
+    func `[table] equals sign`() throws {
         try invalidate(pathComponents: ["table", "equals-sign"])
     }
 
-    @Test("[table] llbrace", .tags(.table))
-    func table__llbrace() throws {
+    @Test(.tags(.table))
+    func `[table] llbrace`() throws {
         try invalidate(pathComponents: ["table", "llbrace"])
     }
 
-    @Test("[table] multiline key 01", .tags(.table))
-    func table__multiline_key_01() throws {
+    @Test(.tags(.table))
+    func `[table] multiline key 01`() throws {
         try invalidate(pathComponents: ["table", "multiline-key-01"])
     }
 
-    @Test("[table] multiline key 02", .tags(.table))
-    func table__multiline_key_02() throws {
+    @Test(.tags(.table))
+    func `[table] multiline key 02`() throws {
         try invalidate(pathComponents: ["table", "multiline-key-02"])
     }
 
-    @Test("[table] nested brackets close", .tags(.table))
-    func table__nested_brackets_close() throws {
+    @Test(.tags(.table))
+    func `[table] nested brackets close`() throws {
         try invalidate(pathComponents: ["table", "nested-brackets-close"])
     }
 
-    @Test("[table] nested brackets open", .tags(.table))
-    func table__nested_brackets_open() throws {
+    @Test(.tags(.table))
+    func `[table] nested brackets open`() throws {
         try invalidate(pathComponents: ["table", "nested-brackets-open"])
     }
 
-    @Test("[table] newline 01", .tags(.table))
-    func table__newline_01() throws {
+    @Test(.tags(.table))
+    func `[table] newline 01`() throws {
         try invalidate(pathComponents: ["table", "newline-01"])
     }
 
-    @Test("[table] newline 02", .tags(.table))
-    func table__newline_02() throws {
+    @Test(.tags(.table))
+    func `[table] newline 02`() throws {
         try invalidate(pathComponents: ["table", "newline-02"])
     }
 
-    @Test("[table] newline 03", .tags(.table))
-    func table__newline_03() throws {
+    @Test(.tags(.table))
+    func `[table] newline 03`() throws {
         try invalidate(pathComponents: ["table", "newline-03"])
     }
 
-    @Test("[table] newline 04", .tags(.table))
-    func table__newline_04() throws {
+    @Test(.tags(.table))
+    func `[table] newline 04`() throws {
         try invalidate(pathComponents: ["table", "newline-04"])
     }
 
-    @Test("[table] newline 05", .tags(.table))
-    func table__newline_05() throws {
+    @Test(.tags(.table))
+    func `[table] newline 05`() throws {
         try invalidate(pathComponents: ["table", "newline-05"])
     }
 
-    @Test("[table] no close 01", .tags(.table))
-    func table__no_close_01() throws {
+    @Test(.tags(.table))
+    func `[table] no close 01`() throws {
         try invalidate(pathComponents: ["table", "no-close-01"])
     }
 
-    @Test("[table] no close 02", .tags(.table))
-    func table__no_close_02() throws {
+    @Test(.tags(.table))
+    func `[table] no close 02`() throws {
         try invalidate(pathComponents: ["table", "no-close-02"])
     }
 
-    @Test("[table] no close 03", .tags(.table))
-    func table__no_close_03() throws {
+    @Test(.tags(.table))
+    func `[table] no close 03`() throws {
         try invalidate(pathComponents: ["table", "no-close-03"])
     }
 
-    @Test("[table] no close 04", .tags(.table))
-    func table__no_close_04() throws {
+    @Test(.tags(.table))
+    func `[table] no close 04`() throws {
         try invalidate(pathComponents: ["table", "no-close-04"])
     }
 
-    @Test("[table] no close 05", .tags(.table))
-    func table__no_close_05() throws {
+    @Test(.tags(.table))
+    func `[table] no close 05`() throws {
         try invalidate(pathComponents: ["table", "no-close-05"])
     }
 
-    @Test("[table] no close 06", .tags(.table))
-    func table__no_close_06() throws {
+    @Test(.tags(.table))
+    func `[table] no close 06`() throws {
         try invalidate(pathComponents: ["table", "no-close-06"])
     }
 
-    @Test("[table] no close 07", .tags(.table))
-    func table__no_close_07() throws {
+    @Test(.tags(.table))
+    func `[table] no close 07`() throws {
         try invalidate(pathComponents: ["table", "no-close-07"])
     }
 
-    @Test("[table] no close 08", .tags(.table))
-    func table__no_close_08() throws {
+    @Test(.tags(.table))
+    func `[table] no close 08`() throws {
         try invalidate(pathComponents: ["table", "no-close-08"])
     }
 
-    @Test("[table] no close 09", .tags(.table))
-    func table__no_close_09() throws {
+    @Test(.tags(.table))
+    func `[table] no close 09`() throws {
         try invalidate(pathComponents: ["table", "no-close-09"])
     }
 
-    @Test("[table] overwrite array in parent", .tags(.table))
-    func table__overwrite_array_in_parent() throws {
+    @Test(.tags(.table))
+    func `[table] overwrite array in parent`() throws {
         try invalidate(pathComponents: ["table", "overwrite-array-in-parent"])
     }
 
-    @Test("[table] overwrite bool with array", .tags(.table))
-    func table__overwrite_bool_with_array() throws {
+    @Test(.tags(.table))
+    func `[table] overwrite bool with array`() throws {
         try invalidate(pathComponents: ["table", "overwrite-bool-with-array"])
     }
 
-    @Test("[table] overwrite with deep table", .tags(.table))
-    func table__overwrite_with_deep_table() throws {
+    @Test(.tags(.table))
+    func `[table] overwrite with deep table`() throws {
         try invalidate(pathComponents: ["table", "overwrite-with-deep-table"])
     }
 
-    @Test("[table] redefine 01", .tags(.table))
-    func table__redefine_01() throws {
+    @Test(.tags(.table))
+    func `[table] redefine 01`() throws {
         try invalidate(pathComponents: ["table", "redefine-01"])
     }
 
-    @Test("[table] redefine 02", .tags(.table))
-    func table__redefine_02() throws {
+    @Test(.tags(.table))
+    func `[table] redefine 02`() throws {
         try invalidate(pathComponents: ["table", "redefine-02"])
     }
 
-    @Test("[table] redefine 03", .tags(.table))
-    func table__redefine_03() throws {
+    @Test(.tags(.table))
+    func `[table] redefine 03`() throws {
         try invalidate(pathComponents: ["table", "redefine-03"])
     }
 
-    @Test("[table] rrbrace", .tags(.table))
-    func table__rrbrace() throws {
+    @Test(.tags(.table))
+    func `[table] rrbrace`() throws {
         try invalidate(pathComponents: ["table", "rrbrace"])
     }
 
-    @Test("[table] super twice", .tags(.table))
-    func table__super_twice() throws {
+    @Test(.tags(.table))
+    func `[table] super twice`() throws {
         try invalidate(pathComponents: ["table", "super-twice"])
     }
 
-    @Test("[table] text after table", .tags(.table))
-    func table__text_after_table() throws {
+    @Test(.tags(.table))
+    func `[table] text after table`() throws {
         try invalidate(pathComponents: ["table", "text-after-table"])
     }
 
-    @Test("[table] trailing dot", .tags(.table))
-    func table__trailing_dot() throws {
+    @Test(.tags(.table))
+    func `[table] trailing dot`() throws {
         try invalidate(pathComponents: ["table", "trailing-dot"])
     }
 
-    @Test("[table] whitespace", .tags(.table))
-    func table__whitespace() throws {
+    @Test(.tags(.table))
+    func `[table] whitespace`() throws {
         try invalidate(pathComponents: ["table", "whitespace"])
     }
 
-    @Test("[table] with pound", .tags(.table))
-    func table__with_pound() throws {
+    @Test(.tags(.table))
+    func `[table] with pound`() throws {
         try invalidate(pathComponents: ["table", "with-pound"])
     }
 }
diff --git a/Tests/TOMLDecoderTests/LeafValueDecodingTests.Generated.swift b/Tests/TOMLDecoderTests/LeafValueDecodingTests.Generated.swift
index f8a96e45..4ecd8aab 100644
--- a/Tests/TOMLDecoderTests/LeafValueDecodingTests.Generated.swift
+++ b/Tests/TOMLDecoderTests/LeafValueDecodingTests.Generated.swift
@@ -5,9 +5,8 @@ import Foundation
 import Testing
 import TOMLDecoder
 
-@Suite
 struct LeafValueDecodingTests {
-    @Test func booleanAsBool() throws {
+    @Test func `boolean as bool`() throws {
         struct Test: Decodable, Equatable {
             let boolean: Bool
             let booleans: [Bool]
@@ -42,7 +41,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func stringAsString() throws {
+    @Test func `string as string`() throws {
         struct Test: Decodable, Equatable {
             let string: String
             let strings: [String]
@@ -77,7 +76,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func integerAsInt() throws {
+    @Test func `integer as int`() throws {
         struct Test: Decodable, Equatable {
             let integer: Int
             let integers: [Int]
@@ -112,7 +111,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func integerAsInt8() throws {
+    @Test func `integer as int 8`() throws {
         struct Test: Decodable, Equatable {
             let integer: Int8
             let integers: [Int8]
@@ -147,7 +146,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func integerAsInt16() throws {
+    @Test func `integer as int 16`() throws {
         struct Test: Decodable, Equatable {
             let integer: Int16
             let integers: [Int16]
@@ -182,7 +181,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func integerAsInt32() throws {
+    @Test func `integer as int 32`() throws {
         struct Test: Decodable, Equatable {
             let integer: Int32
             let integers: [Int32]
@@ -217,7 +216,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func integerAsUInt() throws {
+    @Test func `integer as U int`() throws {
         struct Test: Decodable, Equatable {
             let integer: UInt
             let integers: [UInt]
@@ -252,7 +251,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func integerAsUInt8() throws {
+    @Test func `integer as U int 8`() throws {
         struct Test: Decodable, Equatable {
             let integer: UInt8
             let integers: [UInt8]
@@ -287,7 +286,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func integerAsUInt16() throws {
+    @Test func `integer as U int 16`() throws {
         struct Test: Decodable, Equatable {
             let integer: UInt16
             let integers: [UInt16]
@@ -322,7 +321,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func integerAsUInt32() throws {
+    @Test func `integer as U int 32`() throws {
         struct Test: Decodable, Equatable {
             let integer: UInt32
             let integers: [UInt32]
@@ -357,7 +356,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func integerAsUInt64() throws {
+    @Test func `integer as U int 64`() throws {
         struct Test: Decodable, Equatable {
             let integer: UInt64
             let integers: [UInt64]
@@ -392,7 +391,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func floatAsFloat() throws {
+    @Test func `float as float`() throws {
         struct Test: Decodable, Equatable {
             let float: Float
             let floats: [Float]
@@ -427,7 +426,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func floatAsDouble() throws {
+    @Test func `float as double`() throws {
         struct Test: Decodable, Equatable {
             let float: Double
             let floats: [Double]
@@ -462,7 +461,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func allTheNativeDates() throws {
+    @Test func `all the native dates`() throws {
         struct Test: Decodable, Equatable {
             let localDate: LocalDate
             let localDateFromLocalDateTime: LocalDate
diff --git a/Tests/TOMLDecoderTests/TOMLDecoderTests.swift b/Tests/TOMLDecoderTests/TOMLDecoderTests.swift
index 55663ce4..a1aefed1 100644
--- a/Tests/TOMLDecoderTests/TOMLDecoderTests.swift
+++ b/Tests/TOMLDecoderTests/TOMLDecoderTests.swift
@@ -3,9 +3,8 @@ import Resources
 import Testing
 @testable import TOMLDecoder
 
-@Suite
 struct TOMLDecoderTests {
-    @Test func basicGeneratedCodables() throws {
+    @Test func `basic generated codables`() throws {
         struct Player: Codable, Equatable {
             let id: String
             let health: Int64
@@ -36,7 +35,7 @@ struct TOMLDecoderTests {
         #expect(result == expectation)
     }
 
-    @Test func decodingContainerKeyed() throws {
+    @Test func `decoding container keyed`() throws {
         struct Player: Decodable, Equatable {
             let id: String
             let health: Int64
@@ -74,7 +73,7 @@ struct TOMLDecoderTests {
         #expect(result == expectation)
     }
 
-    @Test func nestedUnkeyedDecodingContainer() throws {
+    @Test func `nested unkeyed decoding container`() throws {
         struct Player: Decodable, Equatable {
             let id: String
             let health: Int64
@@ -126,7 +125,7 @@ struct TOMLDecoderTests {
         #expect(result == expectation)
     }
 
-    @Test func lenientIntegerDecodingStrategy() throws {
+    @Test func `lenient integer decoding strategy`() throws {
         struct Player: Codable, Equatable {
             let id: String
             let health: Int
@@ -145,7 +144,7 @@ struct TOMLDecoderTests {
     }
 
     @Test
-    func foundationDateDecoding() throws {
+    func `foundation date decoding`() throws {
         struct Player: Codable, Equatable {
             let id: String
             let signUpDate: Date
@@ -165,7 +164,7 @@ struct TOMLDecoderTests {
     }
 
     @Test
-    func foundationDateComponentsFromLocalDateDecoding() throws {
+    func `foundation date components from local date decoding`() throws {
         struct Player: Codable, Equatable {
             let id: String
             let signUpDate: DateComponents
@@ -185,7 +184,7 @@ struct TOMLDecoderTests {
     }
 
     @Test
-    func foundationDateComponentsFromLocalTimeDecoding() throws {
+    func `foundation date components from local time decoding`() throws {
         struct Player: Codable, Equatable {
             let id: String
             let signUpTime: DateComponents
@@ -205,7 +204,7 @@ struct TOMLDecoderTests {
     }
 
     @Test
-    func foundationDateComponentsFromLocalDateTimeDecoding() throws {
+    func `foundation date components from local date time decoding`() throws {
         struct Player: Codable, Equatable {
             let id: String
             let signUpTime: DateComponents
@@ -225,7 +224,7 @@ struct TOMLDecoderTests {
         #expect(result == expectation)
     }
 
-    @Test func decodingSnakeCaseKeyStrategy() throws {
+    @Test func `decoding snake case key strategy`() throws {
         struct Player: Codable, Equatable {
             let id: String
             let firstProfession: String
@@ -245,7 +244,7 @@ struct TOMLDecoderTests {
         #expect(result == expectation)
     }
 
-    @Test func decodingCustomKeyStrategy() throws {
+    @Test func `decoding custom key strategy`() throws {
         struct Player: Codable, Equatable {
             let id: String
             let profession: String
@@ -266,7 +265,7 @@ struct TOMLDecoderTests {
         #expect(result == expectation)
     }
 
-    @Test func arrayOfStringsParsing() throws {
+    @Test func `array of strings parsing`() throws {
         struct AppConfig: Codable, Equatable {
             let name: String
             let version: String
@@ -307,7 +306,7 @@ struct TOMLDecoderTests {
         #expect(result == expectation)
     }
 
-    @Test func superDecoder() throws {
+    @Test func `super decoder`() throws {
         class Player: Codable {
             let id: String
             let health: Int
@@ -338,7 +337,7 @@ struct TOMLDecoderTests {
         _ = try decoder.decode(LocalPlayer.self, from: toml)
     }
 
-    @Test func tomlIoExample() throws {
+    @Test func `toml io example`() throws {
         let toml = """
         # This is a TOML document
 
@@ -421,7 +420,7 @@ struct TOMLDecoderTests {
         #expect(result == expectation)
     }
 
-    @Test func mixingContainers() throws {
+    @Test func `mixing containers`() throws {
         struct Test: Decodable, Equatable {
             let numbers: [[Int64]]
             let strings: TOMLArray
@@ -443,7 +442,7 @@ struct TOMLDecoderTests {
         #expect(result.numbers == [[1, 2], [3, 4]])
     }
 
-    @Test func optionalFields() throws {
+    @Test func `optional fields`() throws {
         struct Test: Codable, Equatable {
             let a: Int64?
             let b: Double?
@@ -470,7 +469,7 @@ struct TOMLDecoderTests {
         #expect(result2 == Test(a: nil, b: 1.0, c: "claude"))
     }
 
-    @Test func singleValueContainer() throws {
+    @Test func `single value container`() throws {
         enum Language: String, Codable {
             case swift
             case mojo
diff --git a/Tests/TOMLDecoderTests/TOMLTableKeyMembershipTests.swift b/Tests/TOMLDecoderTests/TOMLTableKeyMembershipTests.swift
index ee9484be..afe6e884 100644
--- a/Tests/TOMLDecoderTests/TOMLTableKeyMembershipTests.swift
+++ b/Tests/TOMLDecoderTests/TOMLTableKeyMembershipTests.swift
@@ -18,16 +18,15 @@ health = 123
 id = "cde"
 health = 456
 """
-@Suite
 struct TOMLTableKeyMembershipTests {
     @Test
-    func allKeysForRootTable() throws {
+    func `all keys for root table`() throws {
         let table = try TOMLTable(source: toml)
         #expect(table.keys == ["a", "b", "players", "c"])
     }
 
     @Test
-    func rootTableKeyContains() throws {
+    func `root table key contains`() throws {
         let table = try TOMLTable(source: toml)
         #expect(table.keys == ["a", "b", "players", "c"])
         #expect(table.contains(key: "a"))
diff --git a/Tests/TOMLDecoderTests/ValidationTests.Generated.swift b/Tests/TOMLDecoderTests/ValidationTests.Generated.swift
index 6f516b08..cee58330 100644
--- a/Tests/TOMLDecoderTests/ValidationTests.Generated.swift
+++ b/Tests/TOMLDecoderTests/ValidationTests.Generated.swift
@@ -5,7 +5,6 @@ import Foundation
 import Testing
 import TOMLDecoder
 
-@Suite
 struct TOMLValidationTests {
     private var directoryURL: URL {
         URL(fileURLWithPath: #filePath)
@@ -20,1073 +19,1073 @@ struct TOMLValidationTests {
         try TOMLComplianceSupport.verifyValidFixture(jsonURL: jsonURL, tomlURL: tomlURL, sourceLocation: sourceLocation)
     }
 
-    @Test("[array] array", .tags(.array))
-    func array__array() throws {
+    @Test(.tags(.array))
+    func `[array] array`() throws {
         try verifyByFixture(pathComponents: ["array", "array"])
     }
 
-    @Test("[array] array subtables", .tags(.array))
-    func array__array_subtables() throws {
+    @Test(.tags(.array))
+    func `[array] array subtables`() throws {
         try verifyByFixture(pathComponents: ["array", "array-subtables"])
     }
 
-    @Test("[array] bool", .tags(.array))
-    func array__bool() throws {
+    @Test(.tags(.array))
+    func `[array] bool`() throws {
         try verifyByFixture(pathComponents: ["array", "bool"])
     }
 
-    @Test("[array] empty", .tags(.array))
-    func array__empty() throws {
+    @Test(.tags(.array))
+    func `[array] empty`() throws {
         try verifyByFixture(pathComponents: ["array", "empty"])
     }
 
-    @Test("[array] hetergeneous", .tags(.array))
-    func array__hetergeneous() throws {
+    @Test(.tags(.array))
+    func `[array] hetergeneous`() throws {
         try verifyByFixture(pathComponents: ["array", "hetergeneous"])
     }
 
-    @Test("[array] mixed int array", .tags(.array))
-    func array__mixed_int_array() throws {
+    @Test(.tags(.array))
+    func `[array] mixed int array`() throws {
         try verifyByFixture(pathComponents: ["array", "mixed-int-array"])
     }
 
-    @Test("[array] mixed int float", .tags(.array))
-    func array__mixed_int_float() throws {
+    @Test(.tags(.array))
+    func `[array] mixed int float`() throws {
         try verifyByFixture(pathComponents: ["array", "mixed-int-float"])
     }
 
-    @Test("[array] mixed int string", .tags(.array))
-    func array__mixed_int_string() throws {
+    @Test(.tags(.array))
+    func `[array] mixed int string`() throws {
         try verifyByFixture(pathComponents: ["array", "mixed-int-string"])
     }
 
-    @Test("[array] mixed string table", .tags(.array))
-    func array__mixed_string_table() throws {
+    @Test(.tags(.array))
+    func `[array] mixed string table`() throws {
         try verifyByFixture(pathComponents: ["array", "mixed-string-table"])
     }
 
-    @Test("[array] nested", .tags(.array))
-    func array__nested() throws {
+    @Test(.tags(.array))
+    func `[array] nested`() throws {
         try verifyByFixture(pathComponents: ["array", "nested"])
     }
 
-    @Test("[array] nested double", .tags(.array))
-    func array__nested_double() throws {
+    @Test(.tags(.array))
+    func `[array] nested double`() throws {
         try verifyByFixture(pathComponents: ["array", "nested-double"])
     }
 
-    @Test("[array] nested inline table", .tags(.array))
-    func array__nested_inline_table() throws {
+    @Test(.tags(.array))
+    func `[array] nested inline table`() throws {
         try verifyByFixture(pathComponents: ["array", "nested-inline-table"])
     }
 
-    @Test("[array] nospaces", .tags(.array))
-    func array__nospaces() throws {
+    @Test(.tags(.array))
+    func `[array] nospaces`() throws {
         try verifyByFixture(pathComponents: ["array", "nospaces"])
     }
 
-    @Test("[array] open parent table", .tags(.array))
-    func array__open_parent_table() throws {
+    @Test(.tags(.array))
+    func `[array] open parent table`() throws {
         try verifyByFixture(pathComponents: ["array", "open-parent-table"])
     }
 
-    @Test("[array] string quote comma 01", .tags(.array))
-    func array__string_quote_comma_01() throws {
+    @Test(.tags(.array))
+    func `[array] string quote comma 01`() throws {
         try verifyByFixture(pathComponents: ["array", "string-quote-comma-01"])
     }
 
-    @Test("[array] string quote comma 02", .tags(.array))
-    func array__string_quote_comma_02() throws {
+    @Test(.tags(.array))
+    func `[array] string quote comma 02`() throws {
         try verifyByFixture(pathComponents: ["array", "string-quote-comma-02"])
     }
 
-    @Test("[array] string with comma 01", .tags(.array))
-    func array__string_with_comma_01() throws {
+    @Test(.tags(.array))
+    func `[array] string with comma 01`() throws {
         try verifyByFixture(pathComponents: ["array", "string-with-comma-01"])
     }
 
-    @Test("[array] string with comma 02", .tags(.array))
-    func array__string_with_comma_02() throws {
+    @Test(.tags(.array))
+    func `[array] string with comma 02`() throws {
         try verifyByFixture(pathComponents: ["array", "string-with-comma-02"])
     }
 
-    @Test("[array] strings", .tags(.array))
-    func array__strings() throws {
+    @Test(.tags(.array))
+    func `[array] strings`() throws {
         try verifyByFixture(pathComponents: ["array", "strings"])
     }
 
-    @Test("[array] table array string backslash", .tags(.array))
-    func array__table_array_string_backslash() throws {
+    @Test(.tags(.array))
+    func `[array] table array string backslash`() throws {
         try verifyByFixture(pathComponents: ["array", "table-array-string-backslash"])
     }
 
-    @Test("[array] trailing comma", .tags(.array))
-    func array__trailing_comma() throws {
+    @Test(.tags(.array))
+    func `[array] trailing comma`() throws {
         try verifyByFixture(pathComponents: ["array", "trailing-comma"])
     }
 
-    @Test("[bool] bool", .tags(.bool))
-    func bool__bool() throws {
+    @Test(.tags(.bool))
+    func `[bool] bool`() throws {
         try verifyByFixture(pathComponents: ["bool", "bool"])
     }
 
-    @Test("[comment] after literal no ws", .tags(.comment))
-    func comment__after_literal_no_ws() throws {
+    @Test(.tags(.comment))
+    func `[comment] after literal no ws`() throws {
         try verifyByFixture(pathComponents: ["comment", "after-literal-no-ws"])
     }
 
-    @Test("[comment] at eof", .tags(.comment))
-    func comment__at_eof() throws {
+    @Test(.tags(.comment))
+    func `[comment] at eof`() throws {
         try verifyByFixture(pathComponents: ["comment", "at-eof"])
     }
 
-    @Test("[comment] at eof2", .tags(.comment))
-    func comment__at_eof2() throws {
+    @Test(.tags(.comment))
+    func `[comment] at eof2`() throws {
         try verifyByFixture(pathComponents: ["comment", "at-eof2"])
     }
 
-    @Test("[comment] everywhere", .tags(.comment))
-    func comment__everywhere() throws {
+    @Test(.tags(.comment))
+    func `[comment] everywhere`() throws {
         try verifyByFixture(pathComponents: ["comment", "everywhere"])
     }
 
-    @Test("[comment] noeol", .tags(.comment))
-    func comment__noeol() throws {
+    @Test(.tags(.comment))
+    func `[comment] noeol`() throws {
         try verifyByFixture(pathComponents: ["comment", "noeol"])
     }
 
-    @Test("[comment] nonascii", .tags(.comment))
-    func comment__nonascii() throws {
+    @Test(.tags(.comment))
+    func `[comment] nonascii`() throws {
         try verifyByFixture(pathComponents: ["comment", "nonascii"])
     }
 
-    @Test("[comment] tricky", .tags(.comment))
-    func comment__tricky() throws {
+    @Test(.tags(.comment))
+    func `[comment] tricky`() throws {
         try verifyByFixture(pathComponents: ["comment", "tricky"])
     }
 
-    @Test("[datetime] datetime", .tags(.datetime))
-    func datetime__datetime() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] datetime`() throws {
         try verifyByFixture(pathComponents: ["datetime", "datetime"])
     }
 
-    @Test("[datetime] edge", .tags(.datetime))
-    func datetime__edge() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] edge`() throws {
         try verifyByFixture(pathComponents: ["datetime", "edge"])
     }
 
-    @Test("[datetime] invalid date in string", .tags(.datetime))
-    func datetime__invalid_date_in_string() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] invalid date in string`() throws {
         try verifyByFixture(pathComponents: ["datetime", "invalid-date-in-string"])
     }
 
-    @Test("[datetime] leap year", .tags(.datetime))
-    func datetime__leap_year() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] leap year`() throws {
         try verifyByFixture(pathComponents: ["datetime", "leap-year"])
     }
 
-    @Test("[datetime] local", .tags(.datetime))
-    func datetime__local() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] local`() throws {
         try verifyByFixture(pathComponents: ["datetime", "local"])
     }
 
-    @Test("[datetime] local date", .tags(.datetime))
-    func datetime__local_date() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] local date`() throws {
         try verifyByFixture(pathComponents: ["datetime", "local-date"])
     }
 
-    @Test("[datetime] local time", .tags(.datetime))
-    func datetime__local_time() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] local time`() throws {
         try verifyByFixture(pathComponents: ["datetime", "local-time"])
     }
 
-    @Test("[datetime] milliseconds", .tags(.datetime))
-    func datetime__milliseconds() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] milliseconds`() throws {
         try verifyByFixture(pathComponents: ["datetime", "milliseconds"])
     }
 
-    @Test("[datetime] no seconds", .tags(.datetime))
-    func datetime__no_seconds() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] no seconds`() throws {
         try verifyByFixture(pathComponents: ["datetime", "no-seconds"])
     }
 
-    @Test("[datetime] timezone", .tags(.datetime))
-    func datetime__timezone() throws {
+    @Test(.tags(.datetime))
+    func `[datetime] timezone`() throws {
         try verifyByFixture(pathComponents: ["datetime", "timezone"])
     }
 
-    @Test("empty crlf")
-    func empty_crlf() throws {
+    @Test
+    func `empty crlf`() throws {
         try verifyByFixture(pathComponents: ["empty-crlf"])
     }
 
-    @Test("empty lf")
-    func empty_lf() throws {
+    @Test
+    func `empty lf`() throws {
         try verifyByFixture(pathComponents: ["empty-lf"])
     }
 
-    @Test("empty nothing")
-    func empty_nothing() throws {
+    @Test
+    func `empty nothing`() throws {
         try verifyByFixture(pathComponents: ["empty-nothing"])
     }
 
-    @Test("empty space")
-    func empty_space() throws {
+    @Test
+    func `empty space`() throws {
         try verifyByFixture(pathComponents: ["empty-space"])
     }
 
-    @Test("empty tab")
-    func empty_tab() throws {
+    @Test
+    func `empty tab`() throws {
         try verifyByFixture(pathComponents: ["empty-tab"])
     }
 
-    @Test("example")
+    @Test
     func example() throws {
         try verifyByFixture(pathComponents: ["example"])
     }
 
-    @Test("[float] exponent", .tags(.float))
-    func float__exponent() throws {
+    @Test(.tags(.float))
+    func `[float] exponent`() throws {
         try verifyByFixture(pathComponents: ["float", "exponent"])
     }
 
-    @Test("[float] float", .tags(.float))
-    func float__float() throws {
+    @Test(.tags(.float))
+    func `[float] float`() throws {
         try verifyByFixture(pathComponents: ["float", "float"])
     }
 
-    @Test("[float] inf and nan", .tags(.float))
-    func float__inf_and_nan() throws {
+    @Test(.tags(.float))
+    func `[float] inf and nan`() throws {
         try verifyByFixture(pathComponents: ["float", "inf-and-nan"])
     }
 
-    @Test("[float] long", .tags(.float))
-    func float__long() throws {
+    @Test(.tags(.float))
+    func `[float] long`() throws {
         try verifyByFixture(pathComponents: ["float", "long"])
     }
 
-    @Test("[float] max int", .tags(.float))
-    func float__max_int() throws {
+    @Test(.tags(.float))
+    func `[float] max int`() throws {
         try verifyByFixture(pathComponents: ["float", "max-int"])
     }
 
-    @Test("[float] underscore", .tags(.float))
-    func float__underscore() throws {
+    @Test(.tags(.float))
+    func `[float] underscore`() throws {
         try verifyByFixture(pathComponents: ["float", "underscore"])
     }
 
-    @Test("[float] zero", .tags(.float))
-    func float__zero() throws {
+    @Test(.tags(.float))
+    func `[float] zero`() throws {
         try verifyByFixture(pathComponents: ["float", "zero"])
     }
 
-    @Test("implicit and explicit after")
-    func implicit_and_explicit_after() throws {
+    @Test
+    func `implicit and explicit after`() throws {
         try verifyByFixture(pathComponents: ["implicit-and-explicit-after"])
     }
 
-    @Test("implicit and explicit before")
-    func implicit_and_explicit_before() throws {
+    @Test
+    func `implicit and explicit before`() throws {
         try verifyByFixture(pathComponents: ["implicit-and-explicit-before"])
     }
 
-    @Test("implicit groups")
-    func implicit_groups() throws {
+    @Test
+    func `implicit groups`() throws {
         try verifyByFixture(pathComponents: ["implicit-groups"])
     }
 
-    @Test("[inline-table] array 01", .tags(.inline_table))
-    func inline_table__array_01() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] array 01`() throws {
         try verifyByFixture(pathComponents: ["inline-table", "array-01"])
     }
 
-    @Test("[inline-table] array 02", .tags(.inline_table))
-    func inline_table__array_02() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] array 02`() throws {
         try verifyByFixture(pathComponents: ["inline-table", "array-02"])
     }
 
-    @Test("[inline-table] array 03", .tags(.inline_table))
-    func inline_table__array_03() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] array 03`() throws {
         try verifyByFixture(pathComponents: ["inline-table", "array-03"])
     }
 
-    @Test("[inline-table] bool", .tags(.inline_table))
-    func inline_table__bool() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] bool`() throws {
         try verifyByFixture(pathComponents: ["inline-table", "bool"])
     }
 
-    @Test("[inline-table] empty", .tags(.inline_table))
-    func inline_table__empty() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] empty`() throws {
         try verifyByFixture(pathComponents: ["inline-table", "empty"])
     }
 
-    @Test("[inline-table] end in bool", .tags(.inline_table))
-    func inline_table__end_in_bool() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] end in bool`() throws {
         try verifyByFixture(pathComponents: ["inline-table", "end-in-bool"])
     }
 
-    @Test("[inline-table] inline table", .tags(.inline_table))
-    func inline_table__inline_table() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] inline table`() throws {
         try verifyByFixture(pathComponents: ["inline-table", "inline-table"])
     }
 
-    @Test("[inline-table] key dotted 01", .tags(.inline_table))
-    func inline_table__key_dotted_01() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] key dotted 01`() throws {
         try verifyByFixture(pathComponents: ["inline-table", "key-dotted-01"])
     }
 
-    @Test("[inline-table] key dotted 02", .tags(.inline_table))
-    func inline_table__key_dotted_02() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] key dotted 02`() throws {
         try verifyByFixture(pathComponents: ["inline-table", "key-dotted-02"])
     }
 
-    @Test("[inline-table] key dotted 03", .tags(.inline_table))
-    func inline_table__key_dotted_03() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] key dotted 03`() throws {
         try verifyByFixture(pathComponents: ["inline-table", "key-dotted-03"])
     }
 
-    @Test("[inline-table] key dotted 04", .tags(.inline_table))
-    func inline_table__key_dotted_04() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] key dotted 04`() throws {
         try verifyByFixture(pathComponents: ["inline-table", "key-dotted-04"])
     }
 
-    @Test("[inline-table] key dotted 05", .tags(.inline_table))
-    func inline_table__key_dotted_05() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] key dotted 05`() throws {
         try verifyByFixture(pathComponents: ["inline-table", "key-dotted-05"])
     }
 
-    @Test("[inline-table] key dotted 06", .tags(.inline_table))
-    func inline_table__key_dotted_06() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] key dotted 06`() throws {
         try verifyByFixture(pathComponents: ["inline-table", "key-dotted-06"])
     }
 
-    @Test("[inline-table] key dotted 07", .tags(.inline_table))
-    func inline_table__key_dotted_07() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] key dotted 07`() throws {
         try verifyByFixture(pathComponents: ["inline-table", "key-dotted-07"])
     }
 
-    @Test("[inline-table] multiline", .tags(.inline_table))
-    func inline_table__multiline() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] multiline`() throws {
         try verifyByFixture(pathComponents: ["inline-table", "multiline"])
     }
 
-    @Test("[inline-table] nest", .tags(.inline_table))
-    func inline_table__nest() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] nest`() throws {
         try verifyByFixture(pathComponents: ["inline-table", "nest"])
     }
 
-    @Test("[inline-table] newline", .tags(.inline_table))
-    func inline_table__newline() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] newline`() throws {
         try verifyByFixture(pathComponents: ["inline-table", "newline"])
     }
 
-    @Test("[inline-table] newline comment", .tags(.inline_table))
-    func inline_table__newline_comment() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] newline comment`() throws {
         try verifyByFixture(pathComponents: ["inline-table", "newline-comment"])
     }
 
-    @Test("[inline-table] spaces", .tags(.inline_table))
-    func inline_table__spaces() throws {
+    @Test(.tags(.inline_table))
+    func `[inline-table] spaces`() throws {
         try verifyByFixture(pathComponents: ["inline-table", "spaces"])
     }
 
-    @Test("[integer] float64 max", .tags(.integer))
-    func integer__float64_max() throws {
+    @Test(.tags(.integer))
+    func `[integer] float64 max`() throws {
         try verifyByFixture(pathComponents: ["integer", "float64-max"])
     }
 
-    @Test("[integer] integer", .tags(.integer))
-    func integer__integer() throws {
+    @Test(.tags(.integer))
+    func `[integer] integer`() throws {
         try verifyByFixture(pathComponents: ["integer", "integer"])
     }
 
-    @Test("[integer] literals", .tags(.integer))
-    func integer__literals() throws {
+    @Test(.tags(.integer))
+    func `[integer] literals`() throws {
         try verifyByFixture(pathComponents: ["integer", "literals"])
     }
 
-    @Test("[integer] long", .tags(.integer))
-    func integer__long() throws {
+    @Test(.tags(.integer))
+    func `[integer] long`() throws {
         try verifyByFixture(pathComponents: ["integer", "long"])
     }
 
-    @Test("[integer] underscore", .tags(.integer))
-    func integer__underscore() throws {
+    @Test(.tags(.integer))
+    func `[integer] underscore`() throws {
         try verifyByFixture(pathComponents: ["integer", "underscore"])
     }
 
-    @Test("[integer] zero", .tags(.integer))
-    func integer__zero() throws {
+    @Test(.tags(.integer))
+    func `[integer] zero`() throws {
         try verifyByFixture(pathComponents: ["integer", "zero"])
     }
 
-    @Test("[key] alphanum", .tags(.key))
-    func key__alphanum() throws {
+    @Test(.tags(.key))
+    func `[key] alphanum`() throws {
         try verifyByFixture(pathComponents: ["key", "alphanum"])
     }
 
-    @Test("[key] case sensitive", .tags(.key))
-    func key__case_sensitive() throws {
+    @Test(.tags(.key))
+    func `[key] case sensitive`() throws {
         try verifyByFixture(pathComponents: ["key", "case-sensitive"])
     }
 
-    @Test("[key] dotted 01", .tags(.key))
-    func key__dotted_01() throws {
+    @Test(.tags(.key))
+    func `[key] dotted 01`() throws {
         try verifyByFixture(pathComponents: ["key", "dotted-01"])
     }
 
-    @Test("[key] dotted 02", .tags(.key))
-    func key__dotted_02() throws {
+    @Test(.tags(.key))
+    func `[key] dotted 02`() throws {
         try verifyByFixture(pathComponents: ["key", "dotted-02"])
     }
 
-    @Test("[key] dotted 03", .tags(.key))
-    func key__dotted_03() throws {
+    @Test(.tags(.key))
+    func `[key] dotted 03`() throws {
         try verifyByFixture(pathComponents: ["key", "dotted-03"])
     }
 
-    @Test("[key] dotted 04", .tags(.key))
-    func key__dotted_04() throws {
+    @Test(.tags(.key))
+    func `[key] dotted 04`() throws {
         try verifyByFixture(pathComponents: ["key", "dotted-04"])
     }
 
-    @Test("[key] dotted empty", .tags(.key))
-    func key__dotted_empty() throws {
+    @Test(.tags(.key))
+    func `[key] dotted empty`() throws {
         try verifyByFixture(pathComponents: ["key", "dotted-empty"])
     }
 
-    @Test("[key] empty 01", .tags(.key))
-    func key__empty_01() throws {
+    @Test(.tags(.key))
+    func `[key] empty 01`() throws {
         try verifyByFixture(pathComponents: ["key", "empty-01"])
     }
 
-    @Test("[key] empty 02", .tags(.key))
-    func key__empty_02() throws {
+    @Test(.tags(.key))
+    func `[key] empty 02`() throws {
         try verifyByFixture(pathComponents: ["key", "empty-02"])
     }
 
-    @Test("[key] empty 03", .tags(.key))
-    func key__empty_03() throws {
+    @Test(.tags(.key))
+    func `[key] empty 03`() throws {
         try verifyByFixture(pathComponents: ["key", "empty-03"])
     }
 
-    @Test("[key] equals nospace", .tags(.key))
-    func key__equals_nospace() throws {
+    @Test(.tags(.key))
+    func `[key] equals nospace`() throws {
         try verifyByFixture(pathComponents: ["key", "equals-nospace"])
     }
 
-    @Test("[key] escapes", .tags(.key))
-    func key__escapes() throws {
+    @Test(.tags(.key))
+    func `[key] escapes`() throws {
         try verifyByFixture(pathComponents: ["key", "escapes"])
     }
 
-    @Test("[key] like date", .tags(.key))
-    func key__like_date() throws {
+    @Test(.tags(.key))
+    func `[key] like date`() throws {
         try verifyByFixture(pathComponents: ["key", "like-date"])
     }
 
-    @Test("[key] numeric 01", .tags(.key))
-    func key__numeric_01() throws {
+    @Test(.tags(.key))
+    func `[key] numeric 01`() throws {
         try verifyByFixture(pathComponents: ["key", "numeric-01"])
     }
 
-    @Test("[key] numeric 02", .tags(.key))
-    func key__numeric_02() throws {
+    @Test(.tags(.key))
+    func `[key] numeric 02`() throws {
         try verifyByFixture(pathComponents: ["key", "numeric-02"])
     }
 
-    @Test("[key] numeric 03", .tags(.key))
-    func key__numeric_03() throws {
+    @Test(.tags(.key))
+    func `[key] numeric 03`() throws {
         try verifyByFixture(pathComponents: ["key", "numeric-03"])
     }
 
-    @Test("[key] numeric 04", .tags(.key))
-    func key__numeric_04() throws {
+    @Test(.tags(.key))
+    func `[key] numeric 04`() throws {
         try verifyByFixture(pathComponents: ["key", "numeric-04"])
     }
 
-    @Test("[key] numeric 05", .tags(.key))
-    func key__numeric_05() throws {
+    @Test(.tags(.key))
+    func `[key] numeric 05`() throws {
         try verifyByFixture(pathComponents: ["key", "numeric-05"])
     }
 
-    @Test("[key] numeric 06", .tags(.key))
-    func key__numeric_06() throws {
+    @Test(.tags(.key))
+    func `[key] numeric 06`() throws {
         try verifyByFixture(pathComponents: ["key", "numeric-06"])
     }
 
-    @Test("[key] numeric 07", .tags(.key))
-    func key__numeric_07() throws {
+    @Test(.tags(.key))
+    func `[key] numeric 07`() throws {
         try verifyByFixture(pathComponents: ["key", "numeric-07"])
     }
 
-    @Test("[key] numeric 08", .tags(.key))
-    func key__numeric_08() throws {
+    @Test(.tags(.key))
+    func `[key] numeric 08`() throws {
         try verifyByFixture(pathComponents: ["key", "numeric-08"])
     }
 
-    @Test("[key] quoted dots", .tags(.key))
-    func key__quoted_dots() throws {
+    @Test(.tags(.key))
+    func `[key] quoted dots`() throws {
         try verifyByFixture(pathComponents: ["key", "quoted-dots"])
     }
 
-    @Test("[key] quoted unicode", .tags(.key))
-    func key__quoted_unicode() throws {
+    @Test(.tags(.key))
+    func `[key] quoted unicode`() throws {
         try verifyByFixture(pathComponents: ["key", "quoted-unicode"])
     }
 
-    @Test("[key] space", .tags(.key))
-    func key__space() throws {
+    @Test(.tags(.key))
+    func `[key] space`() throws {
         try verifyByFixture(pathComponents: ["key", "space"])
     }
 
-    @Test("[key] special chars", .tags(.key))
-    func key__special_chars() throws {
+    @Test(.tags(.key))
+    func `[key] special chars`() throws {
         try verifyByFixture(pathComponents: ["key", "special-chars"])
     }
 
-    @Test("[key] special word", .tags(.key))
-    func key__special_word() throws {
+    @Test(.tags(.key))
+    func `[key] special word`() throws {
         try verifyByFixture(pathComponents: ["key", "special-word"])
     }
 
-    @Test("[key] start", .tags(.key))
-    func key__start() throws {
+    @Test(.tags(.key))
+    func `[key] start`() throws {
         try verifyByFixture(pathComponents: ["key", "start"])
     }
 
-    @Test("[key] zero", .tags(.key))
-    func key__zero() throws {
+    @Test(.tags(.key))
+    func `[key] zero`() throws {
         try verifyByFixture(pathComponents: ["key", "zero"])
     }
 
-    @Test("multibyte")
+    @Test
     func multibyte() throws {
         try verifyByFixture(pathComponents: ["multibyte"])
     }
 
-    @Test("newline crlf")
-    func newline_crlf() throws {
+    @Test
+    func `newline crlf`() throws {
         try verifyByFixture(pathComponents: ["newline-crlf"])
     }
 
-    @Test("newline lf")
-    func newline_lf() throws {
+    @Test
+    func `newline lf`() throws {
         try verifyByFixture(pathComponents: ["newline-lf"])
     }
 
-    @Test("[spec-1.1.0] common 0", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_0() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 0`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-0"])
     }
 
-    @Test("[spec-1.1.0] common 1", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_1() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 1`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-1"])
     }
 
-    @Test("[spec-1.1.0] common 10", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_10() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 10`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-10"])
     }
 
-    @Test("[spec-1.1.0] common 11", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_11() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 11`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-11"])
     }
 
-    @Test("[spec-1.1.0] common 12", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_12() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 12`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-12"])
     }
 
-    @Test("[spec-1.1.0] common 13", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_13() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 13`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-13"])
     }
 
-    @Test("[spec-1.1.0] common 14", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_14() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 14`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-14"])
     }
 
-    @Test("[spec-1.1.0] common 15", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_15() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 15`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-15"])
     }
 
-    @Test("[spec-1.1.0] common 16", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_16() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 16`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-16"])
     }
 
-    @Test("[spec-1.1.0] common 17", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_17() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 17`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-17"])
     }
 
-    @Test("[spec-1.1.0] common 18", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_18() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 18`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-18"])
     }
 
-    @Test("[spec-1.1.0] common 19", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_19() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 19`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-19"])
     }
 
-    @Test("[spec-1.1.0] common 20", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_20() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 20`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-20"])
     }
 
-    @Test("[spec-1.1.0] common 21", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_21() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 21`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-21"])
     }
 
-    @Test("[spec-1.1.0] common 22", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_22() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 22`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-22"])
     }
 
-    @Test("[spec-1.1.0] common 23", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_23() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 23`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-23"])
     }
 
-    @Test("[spec-1.1.0] common 24", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_24() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 24`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-24"])
     }
 
-    @Test("[spec-1.1.0] common 25", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_25() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 25`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-25"])
     }
 
-    @Test("[spec-1.1.0] common 26", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_26() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 26`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-26"])
     }
 
-    @Test("[spec-1.1.0] common 27", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_27() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 27`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-27"])
     }
 
-    @Test("[spec-1.1.0] common 28", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_28() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 28`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-28"])
     }
 
-    @Test("[spec-1.1.0] common 29", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_29() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 29`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-29"])
     }
 
-    @Test("[spec-1.1.0] common 3", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_3() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 3`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-3"])
     }
 
-    @Test("[spec-1.1.0] common 30", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_30() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 30`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-30"])
     }
 
-    @Test("[spec-1.1.0] common 31", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_31() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 31`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-31"])
     }
 
-    @Test("[spec-1.1.0] common 32", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_32() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 32`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-32"])
     }
 
-    @Test("[spec-1.1.0] common 33", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_33() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 33`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-33"])
     }
 
-    @Test("[spec-1.1.0] common 34", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_34() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 34`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-34"])
     }
 
-    @Test("[spec-1.1.0] common 35", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_35() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 35`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-35"])
     }
 
-    @Test("[spec-1.1.0] common 36", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_36() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 36`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-36"])
     }
 
-    @Test("[spec-1.1.0] common 37", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_37() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 37`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-37"])
     }
 
-    @Test("[spec-1.1.0] common 38", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_38() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 38`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-38"])
     }
 
-    @Test("[spec-1.1.0] common 39", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_39() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 39`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-39"])
     }
 
-    @Test("[spec-1.1.0] common 4", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_4() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 4`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-4"])
     }
 
-    @Test("[spec-1.1.0] common 40", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_40() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 40`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-40"])
     }
 
-    @Test("[spec-1.1.0] common 41", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_41() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 41`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-41"])
     }
 
-    @Test("[spec-1.1.0] common 42", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_42() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 42`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-42"])
     }
 
-    @Test("[spec-1.1.0] common 43", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_43() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 43`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-43"])
     }
 
-    @Test("[spec-1.1.0] common 44", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_44() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 44`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-44"])
     }
 
-    @Test("[spec-1.1.0] common 45", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_45() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 45`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-45"])
     }
 
-    @Test("[spec-1.1.0] common 46", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_46() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 46`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-46"])
     }
 
-    @Test("[spec-1.1.0] common 47", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_47() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 47`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-47"])
     }
 
-    @Test("[spec-1.1.0] common 48", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_48() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 48`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-48"])
     }
 
-    @Test("[spec-1.1.0] common 49", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_49() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 49`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-49"])
     }
 
-    @Test("[spec-1.1.0] common 50", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_50() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 50`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-50"])
     }
 
-    @Test("[spec-1.1.0] common 51", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_51() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 51`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-51"])
     }
 
-    @Test("[spec-1.1.0] common 52", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_52() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 52`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-52"])
     }
 
-    @Test("[spec-1.1.0] common 53", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_53() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 53`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-53"])
     }
 
-    @Test("[spec-1.1.0] common 6", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_6() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 6`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-6"])
     }
 
-    @Test("[spec-1.1.0] common 7", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_7() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 7`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-7"])
     }
 
-    @Test("[spec-1.1.0] common 8", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_8() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 8`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-8"])
     }
 
-    @Test("[spec-1.1.0] common 9", .tags(.spec_1_1_0))
-    func spec_1_1_0__common_9() throws {
+    @Test(.tags(.spec_1_1_0))
+    func `[spec-1.1.0] common 9`() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-9"])
     }
 
-    @Test("spec example 1")
-    func spec_example_1() throws {
+    @Test
+    func `spec example 1`() throws {
         try verifyByFixture(pathComponents: ["spec-example-1"])
     }
 
-    @Test("spec example 1 compact")
-    func spec_example_1_compact() throws {
+    @Test
+    func `spec example 1 compact`() throws {
         try verifyByFixture(pathComponents: ["spec-example-1-compact"])
     }
 
-    @Test("[string] basic escape 01", .tags(.string))
-    func string__basic_escape_01() throws {
+    @Test(.tags(.string))
+    func `[string] basic escape 01`() throws {
         try verifyByFixture(pathComponents: ["string", "basic-escape-01"])
     }
 
-    @Test("[string] basic escape 02", .tags(.string))
-    func string__basic_escape_02() throws {
+    @Test(.tags(.string))
+    func `[string] basic escape 02`() throws {
         try verifyByFixture(pathComponents: ["string", "basic-escape-02"])
     }
 
-    @Test("[string] basic escape 03", .tags(.string))
-    func string__basic_escape_03() throws {
+    @Test(.tags(.string))
+    func `[string] basic escape 03`() throws {
         try verifyByFixture(pathComponents: ["string", "basic-escape-03"])
     }
 
-    @Test("[string] empty", .tags(.string))
-    func string__empty() throws {
+    @Test(.tags(.string))
+    func `[string] empty`() throws {
         try verifyByFixture(pathComponents: ["string", "empty"])
     }
 
-    @Test("[string] ends in whitespace escape", .tags(.string))
-    func string__ends_in_whitespace_escape() throws {
+    @Test(.tags(.string))
+    func `[string] ends in whitespace escape`() throws {
         try verifyByFixture(pathComponents: ["string", "ends-in-whitespace-escape"])
     }
 
-    @Test("[string] escape esc", .tags(.string))
-    func string__escape_esc() throws {
+    @Test(.tags(.string))
+    func `[string] escape esc`() throws {
         try verifyByFixture(pathComponents: ["string", "escape-esc"])
     }
 
-    @Test("[string] escape tricky", .tags(.string))
-    func string__escape_tricky() throws {
+    @Test(.tags(.string))
+    func `[string] escape tricky`() throws {
         try verifyByFixture(pathComponents: ["string", "escape-tricky"])
     }
 
-    @Test("[string] escaped escape", .tags(.string))
-    func string__escaped_escape() throws {
+    @Test(.tags(.string))
+    func `[string] escaped escape`() throws {
         try verifyByFixture(pathComponents: ["string", "escaped-escape"])
     }
 
-    @Test("[string] escapes", .tags(.string))
-    func string__escapes() throws {
+    @Test(.tags(.string))
+    func `[string] escapes`() throws {
         try verifyByFixture(pathComponents: ["string", "escapes"])
     }
 
-    @Test("[string] hex escape", .tags(.string))
-    func string__hex_escape() throws {
+    @Test(.tags(.string))
+    func `[string] hex escape`() throws {
         try verifyByFixture(pathComponents: ["string", "hex-escape"])
     }
 
-    @Test("[string] multibyte", .tags(.string))
-    func string__multibyte() throws {
+    @Test(.tags(.string))
+    func `[string] multibyte`() throws {
         try verifyByFixture(pathComponents: ["string", "multibyte"])
     }
 
-    @Test("[string] multibyte escape", .tags(.string))
-    func string__multibyte_escape() throws {
+    @Test(.tags(.string))
+    func `[string] multibyte escape`() throws {
         try verifyByFixture(pathComponents: ["string", "multibyte-escape"])
     }
 
-    @Test("[string] multiline", .tags(.string))
-    func string__multiline() throws {
+    @Test(.tags(.string))
+    func `[string] multiline`() throws {
         try verifyByFixture(pathComponents: ["string", "multiline"])
     }
 
-    @Test("[string] multiline empty", .tags(.string))
-    func string__multiline_empty() throws {
+    @Test(.tags(.string))
+    func `[string] multiline empty`() throws {
         try verifyByFixture(pathComponents: ["string", "multiline-empty"])
     }
 
-    @Test("[string] multiline escaped crlf", .tags(.string))
-    func string__multiline_escaped_crlf() throws {
+    @Test(.tags(.string))
+    func `[string] multiline escaped crlf`() throws {
         try verifyByFixture(pathComponents: ["string", "multiline-escaped-crlf"])
     }
 
-    @Test("[string] multiline quotes", .tags(.string))
-    func string__multiline_quotes() throws {
+    @Test(.tags(.string))
+    func `[string] multiline quotes`() throws {
         try verifyByFixture(pathComponents: ["string", "multiline-quotes"])
     }
 
-    @Test("[string] nl", .tags(.string))
-    func string__nl() throws {
+    @Test(.tags(.string))
+    func `[string] nl`() throws {
         try verifyByFixture(pathComponents: ["string", "nl"])
     }
 
-    @Test("[string] quoted unicode", .tags(.string))
-    func string__quoted_unicode() throws {
+    @Test(.tags(.string))
+    func `[string] quoted unicode`() throws {
         try verifyByFixture(pathComponents: ["string", "quoted-unicode"])
     }
 
-    @Test("[string] raw", .tags(.string))
-    func string__raw() throws {
+    @Test(.tags(.string))
+    func `[string] raw`() throws {
         try verifyByFixture(pathComponents: ["string", "raw"])
     }
 
-    @Test("[string] raw empty", .tags(.string))
-    func string__raw_empty() throws {
+    @Test(.tags(.string))
+    func `[string] raw empty`() throws {
         try verifyByFixture(pathComponents: ["string", "raw-empty"])
     }
 
-    @Test("[string] raw multiline", .tags(.string))
-    func string__raw_multiline() throws {
+    @Test(.tags(.string))
+    func `[string] raw multiline`() throws {
         try verifyByFixture(pathComponents: ["string", "raw-multiline"])
     }
 
-    @Test("[string] simple", .tags(.string))
-    func string__simple() throws {
+    @Test(.tags(.string))
+    func `[string] simple`() throws {
         try verifyByFixture(pathComponents: ["string", "simple"])
     }
 
-    @Test("[string] start mb", .tags(.string))
-    func string__start_mb() throws {
+    @Test(.tags(.string))
+    func `[string] start mb`() throws {
         try verifyByFixture(pathComponents: ["string", "start-mb"])
     }
 
-    @Test("[string] unicode escape", .tags(.string))
-    func string__unicode_escape() throws {
+    @Test(.tags(.string))
+    func `[string] unicode escape`() throws {
         try verifyByFixture(pathComponents: ["string", "unicode-escape"])
     }
 
-    @Test("[string] with pound", .tags(.string))
-    func string__with_pound() throws {
+    @Test(.tags(.string))
+    func `[string] with pound`() throws {
         try verifyByFixture(pathComponents: ["string", "with-pound"])
     }
 
-    @Test("[table] array empty", .tags(.table))
-    func table__array_empty() throws {
+    @Test(.tags(.table))
+    func `[table] array empty`() throws {
         try verifyByFixture(pathComponents: ["table", "array-empty"])
     }
 
-    @Test("[table] array empty name", .tags(.table))
-    func table__array_empty_name() throws {
+    @Test(.tags(.table))
+    func `[table] array empty name`() throws {
         try verifyByFixture(pathComponents: ["table", "array-empty-name"])
     }
 
-    @Test("[table] array implicit", .tags(.table))
-    func table__array_implicit() throws {
+    @Test(.tags(.table))
+    func `[table] array implicit`() throws {
         try verifyByFixture(pathComponents: ["table", "array-implicit"])
     }
 
-    @Test("[table] array implicit and explicit after", .tags(.table))
-    func table__array_implicit_and_explicit_after() throws {
+    @Test(.tags(.table))
+    func `[table] array implicit and explicit after`() throws {
         try verifyByFixture(pathComponents: ["table", "array-implicit-and-explicit-after"])
     }
 
-    @Test("[table] array many", .tags(.table))
-    func table__array_many() throws {
+    @Test(.tags(.table))
+    func `[table] array many`() throws {
         try verifyByFixture(pathComponents: ["table", "array-many"])
     }
 
-    @Test("[table] array nest", .tags(.table))
-    func table__array_nest() throws {
+    @Test(.tags(.table))
+    func `[table] array nest`() throws {
         try verifyByFixture(pathComponents: ["table", "array-nest"])
     }
 
-    @Test("[table] array one", .tags(.table))
-    func table__array_one() throws {
+    @Test(.tags(.table))
+    func `[table] array one`() throws {
         try verifyByFixture(pathComponents: ["table", "array-one"])
     }
 
-    @Test("[table] array table array", .tags(.table))
-    func table__array_table_array() throws {
+    @Test(.tags(.table))
+    func `[table] array table array`() throws {
         try verifyByFixture(pathComponents: ["table", "array-table-array"])
     }
 
-    @Test("[table] array within dotted", .tags(.table))
-    func table__array_within_dotted() throws {
+    @Test(.tags(.table))
+    func `[table] array within dotted`() throws {
         try verifyByFixture(pathComponents: ["table", "array-within-dotted"])
     }
 
-    @Test("[table] empty", .tags(.table))
-    func table__empty() throws {
+    @Test(.tags(.table))
+    func `[table] empty`() throws {
         try verifyByFixture(pathComponents: ["table", "empty"])
     }
 
-    @Test("[table] empty name", .tags(.table))
-    func table__empty_name() throws {
+    @Test(.tags(.table))
+    func `[table] empty name`() throws {
         try verifyByFixture(pathComponents: ["table", "empty-name"])
     }
 
-    @Test("[table] keyword", .tags(.table))
-    func table__keyword() throws {
+    @Test(.tags(.table))
+    func `[table] keyword`() throws {
         try verifyByFixture(pathComponents: ["table", "keyword"])
     }
 
-    @Test("[table] keyword with values", .tags(.table))
-    func table__keyword_with_values() throws {
+    @Test(.tags(.table))
+    func `[table] keyword with values`() throws {
         try verifyByFixture(pathComponents: ["table", "keyword-with-values"])
     }
 
-    @Test("[table] names", .tags(.table))
-    func table__names() throws {
+    @Test(.tags(.table))
+    func `[table] names`() throws {
         try verifyByFixture(pathComponents: ["table", "names"])
     }
 
-    @Test("[table] names with values", .tags(.table))
-    func table__names_with_values() throws {
+    @Test(.tags(.table))
+    func `[table] names with values`() throws {
         try verifyByFixture(pathComponents: ["table", "names-with-values"])
     }
 
-    @Test("[table] no eol", .tags(.table))
-    func table__no_eol() throws {
+    @Test(.tags(.table))
+    func `[table] no eol`() throws {
         try verifyByFixture(pathComponents: ["table", "no-eol"])
     }
 
-    @Test("[table] sub", .tags(.table))
-    func table__sub() throws {
+    @Test(.tags(.table))
+    func `[table] sub`() throws {
         try verifyByFixture(pathComponents: ["table", "sub"])
     }
 
-    @Test("[table] sub empty", .tags(.table))
-    func table__sub_empty() throws {
+    @Test(.tags(.table))
+    func `[table] sub empty`() throws {
         try verifyByFixture(pathComponents: ["table", "sub-empty"])
     }
 
-    @Test("[table] whitespace", .tags(.table))
-    func table__whitespace() throws {
+    @Test(.tags(.table))
+    func `[table] whitespace`() throws {
         try verifyByFixture(pathComponents: ["table", "whitespace"])
     }
 
-    @Test("[table] with literal string", .tags(.table))
-    func table__with_literal_string() throws {
+    @Test(.tags(.table))
+    func `[table] with literal string`() throws {
         try verifyByFixture(pathComponents: ["table", "with-literal-string"])
     }
 
-    @Test("[table] with pound", .tags(.table))
-    func table__with_pound() throws {
+    @Test(.tags(.table))
+    func `[table] with pound`() throws {
         try verifyByFixture(pathComponents: ["table", "with-pound"])
     }
 
-    @Test("[table] with single quotes", .tags(.table))
-    func table__with_single_quotes() throws {
+    @Test(.tags(.table))
+    func `[table] with single quotes`() throws {
         try verifyByFixture(pathComponents: ["table", "with-single-quotes"])
     }
 
-    @Test("[table] without super", .tags(.table))
-    func table__without_super() throws {
+    @Test(.tags(.table))
+    func `[table] without super`() throws {
         try verifyByFixture(pathComponents: ["table", "without-super"])
     }
 
-    @Test("[table] without super with values", .tags(.table))
-    func table__without_super_with_values() throws {
+    @Test(.tags(.table))
+    func `[table] without super with values`() throws {
         try verifyByFixture(pathComponents: ["table", "without-super-with-values"])
     }
 }

From 330e43fcda21949f69132b73f3f13af382d43600 Mon Sep 17 00:00:00 2001
From: Daniel Duan <daniel@duan.ca>
Date: Thu, 9 Jul 2026 01:43:07 -0700
Subject: [PATCH 3/4] Revert "Format with pinned SwiftFormat"

This reverts commit 7de363133c62ffaa87f966a5af8567b8a035a020.
---
 Sources/TOMLDecoder/DateTime.swift            |    4 +-
 .../TOMLDecoderTests/DateStrategyTests.swift  |   29 +-
 .../DateTimeDescriptionTests.swift            |   19 +-
 .../DateTimeExactMatchTests.swift             |   13 +-
 .../InvalidationTests.Generated.swift         | 1865 +++++++++--------
 .../LeafValueDecodingTests.Generated.swift    |   29 +-
 Tests/TOMLDecoderTests/TOMLDecoderTests.swift |   33 +-
 .../TOMLTableKeyMembershipTests.swift         |    5 +-
 .../ValidationTests.Generated.swift           |  853 ++++----
 9 files changed, 1428 insertions(+), 1422 deletions(-)

diff --git a/Sources/TOMLDecoder/DateTime.swift b/Sources/TOMLDecoder/DateTime.swift
index e42398af..e38b5daa 100644
--- a/Sources/TOMLDecoder/DateTime.swift
+++ b/Sources/TOMLDecoder/DateTime.swift
@@ -134,9 +134,7 @@ public struct OffsetDateTime: Equatable, Hashable, Sendable, Codable, CustomStri
         let offsetInSeconds = Int64(offset) * 60
 
         var y = year
-        if month <= 2 {
-            y -= 1
-        }
+        if month <= 2 { y -= 1 }
 
         let era = (y >= 0 ? y : y - 399) / 400
         let yoe = y - era * 400
diff --git a/Tests/TOMLDecoderTests/DateStrategyTests.swift b/Tests/TOMLDecoderTests/DateStrategyTests.swift
index 44752079..4eb475ce 100644
--- a/Tests/TOMLDecoderTests/DateStrategyTests.swift
+++ b/Tests/TOMLDecoderTests/DateStrategyTests.swift
@@ -2,9 +2,10 @@ import Foundation
 import Testing
 @testable import TOMLDecoder
 
+@Suite
 struct DateStrategyTests {
     @Test(.tags(.datetime))
-    func `datetime as date by key`() throws {
+    func datetimeAsDateByKey() throws {
         struct Test: Decodable {
             let datetime: OffsetDateTime
         }
@@ -25,7 +26,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func `datetime as date`() throws {
+    func datetimeAsDate() throws {
         struct Test: Decodable {
             let datetime: Date
         }
@@ -41,7 +42,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func `datetime as time interval since 1970`() throws {
+    func datetimeAsTimeIntervalSince1970() throws {
         struct Test: Decodable {
             let datetime: TimeInterval
         }
@@ -57,7 +58,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func `datetime as time interval since 2001`() throws {
+    func datetimeAsTimeIntervalSince2001() throws {
         struct Test: Decodable {
             let datetime: TimeInterval
         }
@@ -73,7 +74,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func `datetime as proleptic gregorian date`() throws {
+    func datetimeAsProlepticGregorianDate() throws {
         struct Test: Decodable {
             let datetime: Date
         }
@@ -89,7 +90,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func `datetime as custom calendar`() throws {
+    func datetimeAsCustomCalendar() throws {
         struct Test: Decodable {
             let datetime: Date
         }
@@ -105,7 +106,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func `datetime with strict strategy`() throws {
+    func datetimeWithStrictStrategy() throws {
         struct Test: Decodable {
             let datetime: Date
         }
@@ -123,7 +124,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func `datetime as offset date time in array`() throws {
+    func datetimeAsOffsetDateTimeInArray() throws {
         struct Test: Decodable {
             let datetimes: [OffsetDateTime]
         }
@@ -144,7 +145,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func `datetime as date in array`() throws {
+    func datetimeAsDateInArray() throws {
         struct Test: Decodable {
             let datetimes: [Date]
         }
@@ -160,7 +161,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func `datetime as time interval since 1970 in array`() throws {
+    func datetimeAsTimeIntervalSince1970InArray() throws {
         struct Test: Decodable {
             let datetimes: [TimeInterval]
         }
@@ -176,7 +177,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func `datetime as time interval since 2001 in array`() throws {
+    func datetimeAsTimeIntervalSince2001InArray() throws {
         struct Test: Decodable {
             let datetimes: [TimeInterval]
         }
@@ -192,7 +193,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func `datetime as proleptic gregorian date in array`() throws {
+    func datetimeAsProlepticGregorianDateInArray() throws {
         struct Test: Decodable {
             let datetimes: [Date]
         }
@@ -208,7 +209,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func `datetime as custom calendar in array`() throws {
+    func datetimeAsCustomCalendarInArray() throws {
         struct Test: Decodable {
             let datetimes: [Date]
         }
@@ -224,7 +225,7 @@ struct DateStrategyTests {
     }
 
     @Test(.tags(.datetime))
-    func `datetime with strict strategy in array`() throws {
+    func datetimeWithStrictStrategyInArray() throws {
         struct Test: Decodable {
             let datetimes: [Date]
         }
diff --git a/Tests/TOMLDecoderTests/DateTimeDescriptionTests.swift b/Tests/TOMLDecoderTests/DateTimeDescriptionTests.swift
index 841fce82..d45e4fba 100644
--- a/Tests/TOMLDecoderTests/DateTimeDescriptionTests.swift
+++ b/Tests/TOMLDecoderTests/DateTimeDescriptionTests.swift
@@ -1,9 +1,10 @@
 import Testing
 @testable import TOMLDecoder
 
+@Suite
 struct DateTimeDescriptionTests {
     @Test(.tags(.local_date))
-    func `local date basic formatting`() {
+    func localDateBasicFormatting() {
         let date = LocalDate(year: 2023, month: 5, day: 27)
         #expect(date.description == "2023-05-27")
 
@@ -12,7 +13,7 @@ struct DateTimeDescriptionTests {
     }
 
     @Test(.tags(.local_time))
-    func `local time without fractional seconds`() {
+    func localTimeWithoutFractionalSeconds() {
         let time = LocalTime(hour: 7, minute: 32, second: 0, nanosecond: 0)
         #expect(time.description == "07:32:00")
 
@@ -21,7 +22,7 @@ struct DateTimeDescriptionTests {
     }
 
     @Test(.tags(.local_time))
-    func `local time with fractional seconds`() {
+    func localTimeWithFractionalSeconds() {
         let timeWithMicroseconds = LocalTime(hour: 7, minute: 32, second: 0, nanosecond: 999_000_000)
         #expect(timeWithMicroseconds.description == "07:32:00.999")
 
@@ -36,7 +37,7 @@ struct DateTimeDescriptionTests {
     }
 
     @Test(.tags(.local_datetime))
-    func `local date time basic formatting`() {
+    func localDateTimeBasicFormatting() {
         let date = LocalDate(year: 1979, month: 5, day: 27)
         let time = LocalTime(hour: 7, minute: 32, second: 0, nanosecond: 0)
         let dateTime = LocalDateTime(date: date, time: time)
@@ -48,7 +49,7 @@ struct DateTimeDescriptionTests {
     }
 
     @Test(.tags(.datetime))
-    func `offset date time Z suffix formatting`() {
+    func offsetDateTimeZSuffixFormatting() {
         let date = LocalDate(year: 1979, month: 5, day: 27)
         let time = LocalTime(hour: 7, minute: 32, second: 0, nanosecond: 0)
         let uppercaseZ = OffsetDateTime(date: date, time: time, offset: 0, features: [.uppercaseZ])
@@ -59,7 +60,7 @@ struct DateTimeDescriptionTests {
     }
 
     @Test(.tags(.datetime))
-    func `offset date time numeric offset formatting`() {
+    func offsetDateTimeNumericOffsetFormatting() {
         let date = LocalDate(year: 1979, month: 5, day: 27)
         let time = LocalTime(hour: 0, minute: 32, second: 0, nanosecond: 0)
 
@@ -74,7 +75,7 @@ struct DateTimeDescriptionTests {
     }
 
     @Test(.tags(.datetime))
-    func `offset date time lowercase T separator`() {
+    func offsetDateTimeLowercaseTSeparator() {
         let date = LocalDate(year: 1979, month: 5, day: 27)
         let time = LocalTime(hour: 7, minute: 32, second: 0, nanosecond: 0)
 
@@ -86,7 +87,7 @@ struct DateTimeDescriptionTests {
     }
 
     @Test(.tags(.datetime))
-    func `offset date time with fractional seconds`() {
+    func offsetDateTimeWithFractionalSeconds() {
         let date = LocalDate(year: 1979, month: 5, day: 27)
         let timeWithFraction = LocalTime(hour: 0, minute: 32, second: 0, nanosecond: 999_999_000)
 
@@ -95,7 +96,7 @@ struct DateTimeDescriptionTests {
     }
 
     @Test(.tags(.datetime))
-    func `offset date time validation with Z flags`() {
+    func offsetDateTimeValidationWithZFlags() {
         let date = LocalDate(year: 1979, month: 5, day: 27)
         let time = LocalTime(hour: 7, minute: 32, second: 0, nanosecond: 0)
 
diff --git a/Tests/TOMLDecoderTests/DateTimeExactMatchTests.swift b/Tests/TOMLDecoderTests/DateTimeExactMatchTests.swift
index 75decd60..39fb1c19 100644
--- a/Tests/TOMLDecoderTests/DateTimeExactMatchTests.swift
+++ b/Tests/TOMLDecoderTests/DateTimeExactMatchTests.swift
@@ -1,9 +1,10 @@
 import Testing
 import TOMLDecoder
 
+@Suite
 struct DateTimeExactMatchTests {
     @Test(.tags(.local_date))
-    func `local date exact match`() throws {
+    func localDateExactMatch() throws {
         let toml = """
         date = 2021-01-01
         date_with_time = 2021-01-01T01:02:03
@@ -21,7 +22,7 @@ struct DateTimeExactMatchTests {
     }
 
     @Test(.tags(.local_time))
-    func `local time exact match`() throws {
+    func localTimeExactMatch() throws {
         let toml = """
         time = 01:02:03
         time_with_date = 2021-01-01T01:02:03
@@ -39,7 +40,7 @@ struct DateTimeExactMatchTests {
     }
 
     @Test(.tags(.local_datetime))
-    func `local datetime exact match`() throws {
+    func localDatetimeExactMatch() throws {
         let toml = """
         datetime = 2021-01-01T01:02:03
         datetime_with_offset = 2021-01-01T01:02:03+01:00
@@ -55,7 +56,7 @@ struct DateTimeExactMatchTests {
     }
 
     @Test(.tags(.local_date, .array))
-    func `local date exact match in array`() throws {
+    func localDateExactMatchInArray() throws {
         let toml = """
         dates = [2021-01-01, 2021-01-01T01:02:03, 2021-01-01T01:02:03+01:00]
         """
@@ -72,7 +73,7 @@ struct DateTimeExactMatchTests {
     }
 
     @Test(.tags(.local_time, .array))
-    func `local time exact match in array`() throws {
+    func localTimeExactMatchInArray() throws {
         let toml = """
         times = [01:02:03, 2021-01-01T01:02:03, 2021-01-01T01:02:03+01:00]
         """
@@ -89,7 +90,7 @@ struct DateTimeExactMatchTests {
     }
 
     @Test(.tags(.local_datetime, .array))
-    func `local datetime exact match in array`() throws {
+    func localDatetimeExactMatchInArray() throws {
         let toml = """
         datetimes = [2021-01-01T01:02:03, 2021-01-01T01:02:03+01:00]
         """
diff --git a/Tests/TOMLDecoderTests/InvalidationTests.Generated.swift b/Tests/TOMLDecoderTests/InvalidationTests.Generated.swift
index 77c773db..2705b370 100644
--- a/Tests/TOMLDecoderTests/InvalidationTests.Generated.swift
+++ b/Tests/TOMLDecoderTests/InvalidationTests.Generated.swift
@@ -5,6 +5,7 @@ import Foundation
 import Testing
 import TOMLDecoder
 
+@Suite
 struct TOMLInvalidationTests {
     private var directoryURL: URL {
         URL(fileURLWithPath: #filePath)
@@ -18,2333 +19,2333 @@ struct TOMLInvalidationTests {
         try TOMLComplianceSupport.verifyInvalidFixture(tomlURL: tomlURL, sourceLocation: sourceLocation)
     }
 
-    @Test(.tags(.array))
-    func `[array] double comma 01`() throws {
+    @Test("[array] double comma 01", .tags(.array))
+    func array__double_comma_01() throws {
         try invalidate(pathComponents: ["array", "double-comma-01"])
     }
 
-    @Test(.tags(.array))
-    func `[array] double comma 02`() throws {
+    @Test("[array] double comma 02", .tags(.array))
+    func array__double_comma_02() throws {
         try invalidate(pathComponents: ["array", "double-comma-02"])
     }
 
-    @Test(.tags(.array))
-    func `[array] extend defined aot`() throws {
+    @Test("[array] extend defined aot", .tags(.array))
+    func array__extend_defined_aot() throws {
         try invalidate(pathComponents: ["array", "extend-defined-aot"])
     }
 
-    @Test(.tags(.array))
-    func `[array] extending table`() throws {
+    @Test("[array] extending table", .tags(.array))
+    func array__extending_table() throws {
         try invalidate(pathComponents: ["array", "extending-table"])
     }
 
-    @Test(.tags(.array))
-    func `[array] missing separator 01`() throws {
+    @Test("[array] missing separator 01", .tags(.array))
+    func array__missing_separator_01() throws {
         try invalidate(pathComponents: ["array", "missing-separator-01"])
     }
 
-    @Test(.tags(.array))
-    func `[array] missing separator 02`() throws {
+    @Test("[array] missing separator 02", .tags(.array))
+    func array__missing_separator_02() throws {
         try invalidate(pathComponents: ["array", "missing-separator-02"])
     }
 
-    @Test(.tags(.array))
-    func `[array] no close 01`() throws {
+    @Test("[array] no close 01", .tags(.array))
+    func array__no_close_01() throws {
         try invalidate(pathComponents: ["array", "no-close-01"])
     }
 
-    @Test(.tags(.array))
-    func `[array] no close 02`() throws {
+    @Test("[array] no close 02", .tags(.array))
+    func array__no_close_02() throws {
         try invalidate(pathComponents: ["array", "no-close-02"])
     }
 
-    @Test(.tags(.array))
-    func `[array] no close 03`() throws {
+    @Test("[array] no close 03", .tags(.array))
+    func array__no_close_03() throws {
         try invalidate(pathComponents: ["array", "no-close-03"])
     }
 
-    @Test(.tags(.array))
-    func `[array] no close 04`() throws {
+    @Test("[array] no close 04", .tags(.array))
+    func array__no_close_04() throws {
         try invalidate(pathComponents: ["array", "no-close-04"])
     }
 
-    @Test(.tags(.array))
-    func `[array] no close 05`() throws {
+    @Test("[array] no close 05", .tags(.array))
+    func array__no_close_05() throws {
         try invalidate(pathComponents: ["array", "no-close-05"])
     }
 
-    @Test(.tags(.array))
-    func `[array] no close 06`() throws {
+    @Test("[array] no close 06", .tags(.array))
+    func array__no_close_06() throws {
         try invalidate(pathComponents: ["array", "no-close-06"])
     }
 
-    @Test(.tags(.array))
-    func `[array] no close 07`() throws {
+    @Test("[array] no close 07", .tags(.array))
+    func array__no_close_07() throws {
         try invalidate(pathComponents: ["array", "no-close-07"])
     }
 
-    @Test(.tags(.array))
-    func `[array] no close 08`() throws {
+    @Test("[array] no close 08", .tags(.array))
+    func array__no_close_08() throws {
         try invalidate(pathComponents: ["array", "no-close-08"])
     }
 
-    @Test(.tags(.array))
-    func `[array] no close table 01`() throws {
+    @Test("[array] no close table 01", .tags(.array))
+    func array__no_close_table_01() throws {
         try invalidate(pathComponents: ["array", "no-close-table-01"])
     }
 
-    @Test(.tags(.array))
-    func `[array] no close table 02`() throws {
+    @Test("[array] no close table 02", .tags(.array))
+    func array__no_close_table_02() throws {
         try invalidate(pathComponents: ["array", "no-close-table-02"])
     }
 
-    @Test(.tags(.array))
-    func `[array] no comma 01`() throws {
+    @Test("[array] no comma 01", .tags(.array))
+    func array__no_comma_01() throws {
         try invalidate(pathComponents: ["array", "no-comma-01"])
     }
 
-    @Test(.tags(.array))
-    func `[array] no comma 02`() throws {
+    @Test("[array] no comma 02", .tags(.array))
+    func array__no_comma_02() throws {
         try invalidate(pathComponents: ["array", "no-comma-02"])
     }
 
-    @Test(.tags(.array))
-    func `[array] no comma 03`() throws {
+    @Test("[array] no comma 03", .tags(.array))
+    func array__no_comma_03() throws {
         try invalidate(pathComponents: ["array", "no-comma-03"])
     }
 
-    @Test(.tags(.array))
-    func `[array] only comma 01`() throws {
+    @Test("[array] only comma 01", .tags(.array))
+    func array__only_comma_01() throws {
         try invalidate(pathComponents: ["array", "only-comma-01"])
     }
 
-    @Test(.tags(.array))
-    func `[array] only comma 02`() throws {
+    @Test("[array] only comma 02", .tags(.array))
+    func array__only_comma_02() throws {
         try invalidate(pathComponents: ["array", "only-comma-02"])
     }
 
-    @Test(.tags(.array))
-    func `[array] tables 01`() throws {
+    @Test("[array] tables 01", .tags(.array))
+    func array__tables_01() throws {
         try invalidate(pathComponents: ["array", "tables-01"])
     }
 
-    @Test(.tags(.array))
-    func `[array] tables 02`() throws {
+    @Test("[array] tables 02", .tags(.array))
+    func array__tables_02() throws {
         try invalidate(pathComponents: ["array", "tables-02"])
     }
 
-    @Test(.tags(.array))
-    func `[array] text after array entries`() throws {
+    @Test("[array] text after array entries", .tags(.array))
+    func array__text_after_array_entries() throws {
         try invalidate(pathComponents: ["array", "text-after-array-entries"])
     }
 
-    @Test(.tags(.array))
-    func `[array] text before array separator`() throws {
+    @Test("[array] text before array separator", .tags(.array))
+    func array__text_before_array_separator() throws {
         try invalidate(pathComponents: ["array", "text-before-array-separator"])
     }
 
-    @Test(.tags(.array))
-    func `[array] text in array`() throws {
+    @Test("[array] text in array", .tags(.array))
+    func array__text_in_array() throws {
         try invalidate(pathComponents: ["array", "text-in-array"])
     }
 
-    @Test(.tags(.bool))
-    func `[bool] almost false`() throws {
+    @Test("[bool] almost false", .tags(.bool))
+    func bool__almost_false() throws {
         try invalidate(pathComponents: ["bool", "almost-false"])
     }
 
-    @Test(.tags(.bool))
-    func `[bool] almost false with extra`() throws {
+    @Test("[bool] almost false with extra", .tags(.bool))
+    func bool__almost_false_with_extra() throws {
         try invalidate(pathComponents: ["bool", "almost-false-with-extra"])
     }
 
-    @Test(.tags(.bool))
-    func `[bool] almost true`() throws {
+    @Test("[bool] almost true", .tags(.bool))
+    func bool__almost_true() throws {
         try invalidate(pathComponents: ["bool", "almost-true"])
     }
 
-    @Test(.tags(.bool))
-    func `[bool] almost true with extra`() throws {
+    @Test("[bool] almost true with extra", .tags(.bool))
+    func bool__almost_true_with_extra() throws {
         try invalidate(pathComponents: ["bool", "almost-true-with-extra"])
     }
 
-    @Test(.tags(.bool))
-    func `[bool] capitalized false`() throws {
+    @Test("[bool] capitalized false", .tags(.bool))
+    func bool__capitalized_false() throws {
         try invalidate(pathComponents: ["bool", "capitalized-false"])
     }
 
-    @Test(.tags(.bool))
-    func `[bool] capitalized true`() throws {
+    @Test("[bool] capitalized true", .tags(.bool))
+    func bool__capitalized_true() throws {
         try invalidate(pathComponents: ["bool", "capitalized-true"])
     }
 
-    @Test(.tags(.bool))
-    func `[bool] just f`() throws {
+    @Test("[bool] just f", .tags(.bool))
+    func bool__just_f() throws {
         try invalidate(pathComponents: ["bool", "just-f"])
     }
 
-    @Test(.tags(.bool))
-    func `[bool] just t`() throws {
+    @Test("[bool] just t", .tags(.bool))
+    func bool__just_t() throws {
         try invalidate(pathComponents: ["bool", "just-t"])
     }
 
-    @Test(.tags(.bool))
-    func `[bool] mixed case`() throws {
+    @Test("[bool] mixed case", .tags(.bool))
+    func bool__mixed_case() throws {
         try invalidate(pathComponents: ["bool", "mixed-case"])
     }
 
-    @Test(.tags(.bool))
-    func `[bool] mixed case false`() throws {
+    @Test("[bool] mixed case false", .tags(.bool))
+    func bool__mixed_case_false() throws {
         try invalidate(pathComponents: ["bool", "mixed-case-false"])
     }
 
-    @Test(.tags(.bool))
-    func `[bool] mixed case true`() throws {
+    @Test("[bool] mixed case true", .tags(.bool))
+    func bool__mixed_case_true() throws {
         try invalidate(pathComponents: ["bool", "mixed-case-true"])
     }
 
-    @Test(.tags(.bool))
-    func `[bool] starting same false`() throws {
+    @Test("[bool] starting same false", .tags(.bool))
+    func bool__starting_same_false() throws {
         try invalidate(pathComponents: ["bool", "starting-same-false"])
     }
 
-    @Test(.tags(.bool))
-    func `[bool] starting same true`() throws {
+    @Test("[bool] starting same true", .tags(.bool))
+    func bool__starting_same_true() throws {
         try invalidate(pathComponents: ["bool", "starting-same-true"])
     }
 
-    @Test(.tags(.bool))
-    func `[bool] wrong case false`() throws {
+    @Test("[bool] wrong case false", .tags(.bool))
+    func bool__wrong_case_false() throws {
         try invalidate(pathComponents: ["bool", "wrong-case-false"])
     }
 
-    @Test(.tags(.bool))
-    func `[bool] wrong case true`() throws {
+    @Test("[bool] wrong case true", .tags(.bool))
+    func bool__wrong_case_true() throws {
         try invalidate(pathComponents: ["bool", "wrong-case-true"])
     }
 
-    @Test(.tags(.control))
-    func `[control] bare cr`() throws {
+    @Test("[control] bare cr", .tags(.control))
+    func control__bare_cr() throws {
         try invalidate(pathComponents: ["control", "bare-cr"])
     }
 
-    @Test(.tags(.control))
-    func `[control] bare formfeed`() throws {
+    @Test("[control] bare formfeed", .tags(.control))
+    func control__bare_formfeed() throws {
         try invalidate(pathComponents: ["control", "bare-formfeed"])
     }
 
-    @Test(.tags(.control))
-    func `[control] bare null`() throws {
+    @Test("[control] bare null", .tags(.control))
+    func control__bare_null() throws {
         try invalidate(pathComponents: ["control", "bare-null"])
     }
 
-    @Test(.tags(.control))
-    func `[control] bare vertical tab`() throws {
+    @Test("[control] bare vertical tab", .tags(.control))
+    func control__bare_vertical_tab() throws {
         try invalidate(pathComponents: ["control", "bare-vertical-tab"])
     }
 
-    @Test(.tags(.control))
-    func `[control] comment cr`() throws {
+    @Test("[control] comment cr", .tags(.control))
+    func control__comment_cr() throws {
         try invalidate(pathComponents: ["control", "comment-cr"])
     }
 
-    @Test(.tags(.control))
-    func `[control] comment del`() throws {
+    @Test("[control] comment del", .tags(.control))
+    func control__comment_del() throws {
         try invalidate(pathComponents: ["control", "comment-del"])
     }
 
-    @Test(.tags(.control))
-    func `[control] comment ff`() throws {
+    @Test("[control] comment ff", .tags(.control))
+    func control__comment_ff() throws {
         try invalidate(pathComponents: ["control", "comment-ff"])
     }
 
-    @Test(.tags(.control))
-    func `[control] comment lf`() throws {
+    @Test("[control] comment lf", .tags(.control))
+    func control__comment_lf() throws {
         try invalidate(pathComponents: ["control", "comment-lf"])
     }
 
-    @Test(.tags(.control))
-    func `[control] comment null`() throws {
+    @Test("[control] comment null", .tags(.control))
+    func control__comment_null() throws {
         try invalidate(pathComponents: ["control", "comment-null"])
     }
 
-    @Test(.tags(.control))
-    func `[control] comment us`() throws {
+    @Test("[control] comment us", .tags(.control))
+    func control__comment_us() throws {
         try invalidate(pathComponents: ["control", "comment-us"])
     }
 
-    @Test(.tags(.control))
-    func `[control] multi cr`() throws {
+    @Test("[control] multi cr", .tags(.control))
+    func control__multi_cr() throws {
         try invalidate(pathComponents: ["control", "multi-cr"])
     }
 
-    @Test(.tags(.control))
-    func `[control] multi del`() throws {
+    @Test("[control] multi del", .tags(.control))
+    func control__multi_del() throws {
         try invalidate(pathComponents: ["control", "multi-del"])
     }
 
-    @Test(.tags(.control))
-    func `[control] multi lf`() throws {
+    @Test("[control] multi lf", .tags(.control))
+    func control__multi_lf() throws {
         try invalidate(pathComponents: ["control", "multi-lf"])
     }
 
-    @Test(.tags(.control))
-    func `[control] multi null`() throws {
+    @Test("[control] multi null", .tags(.control))
+    func control__multi_null() throws {
         try invalidate(pathComponents: ["control", "multi-null"])
     }
 
-    @Test(.tags(.control))
-    func `[control] multi us`() throws {
+    @Test("[control] multi us", .tags(.control))
+    func control__multi_us() throws {
         try invalidate(pathComponents: ["control", "multi-us"])
     }
 
-    @Test(.tags(.control))
-    func `[control] only ff`() throws {
+    @Test("[control] only ff", .tags(.control))
+    func control__only_ff() throws {
         try invalidate(pathComponents: ["control", "only-ff"])
     }
 
-    @Test(.tags(.control))
-    func `[control] only null`() throws {
+    @Test("[control] only null", .tags(.control))
+    func control__only_null() throws {
         try invalidate(pathComponents: ["control", "only-null"])
     }
 
-    @Test(.tags(.control))
-    func `[control] only vt`() throws {
+    @Test("[control] only vt", .tags(.control))
+    func control__only_vt() throws {
         try invalidate(pathComponents: ["control", "only-vt"])
     }
 
-    @Test(.tags(.control))
-    func `[control] rawmulti cr`() throws {
+    @Test("[control] rawmulti cr", .tags(.control))
+    func control__rawmulti_cr() throws {
         try invalidate(pathComponents: ["control", "rawmulti-cr"])
     }
 
-    @Test(.tags(.control))
-    func `[control] rawmulti del`() throws {
+    @Test("[control] rawmulti del", .tags(.control))
+    func control__rawmulti_del() throws {
         try invalidate(pathComponents: ["control", "rawmulti-del"])
     }
 
-    @Test(.tags(.control))
-    func `[control] rawmulti lf`() throws {
+    @Test("[control] rawmulti lf", .tags(.control))
+    func control__rawmulti_lf() throws {
         try invalidate(pathComponents: ["control", "rawmulti-lf"])
     }
 
-    @Test(.tags(.control))
-    func `[control] rawmulti null`() throws {
+    @Test("[control] rawmulti null", .tags(.control))
+    func control__rawmulti_null() throws {
         try invalidate(pathComponents: ["control", "rawmulti-null"])
     }
 
-    @Test(.tags(.control))
-    func `[control] rawmulti us`() throws {
+    @Test("[control] rawmulti us", .tags(.control))
+    func control__rawmulti_us() throws {
         try invalidate(pathComponents: ["control", "rawmulti-us"])
     }
 
-    @Test(.tags(.control))
-    func `[control] rawstring cr`() throws {
+    @Test("[control] rawstring cr", .tags(.control))
+    func control__rawstring_cr() throws {
         try invalidate(pathComponents: ["control", "rawstring-cr"])
     }
 
-    @Test(.tags(.control))
-    func `[control] rawstring del`() throws {
+    @Test("[control] rawstring del", .tags(.control))
+    func control__rawstring_del() throws {
         try invalidate(pathComponents: ["control", "rawstring-del"])
     }
 
-    @Test(.tags(.control))
-    func `[control] rawstring lf`() throws {
+    @Test("[control] rawstring lf", .tags(.control))
+    func control__rawstring_lf() throws {
         try invalidate(pathComponents: ["control", "rawstring-lf"])
     }
 
-    @Test(.tags(.control))
-    func `[control] rawstring null`() throws {
+    @Test("[control] rawstring null", .tags(.control))
+    func control__rawstring_null() throws {
         try invalidate(pathComponents: ["control", "rawstring-null"])
     }
 
-    @Test(.tags(.control))
-    func `[control] rawstring us`() throws {
+    @Test("[control] rawstring us", .tags(.control))
+    func control__rawstring_us() throws {
         try invalidate(pathComponents: ["control", "rawstring-us"])
     }
 
-    @Test(.tags(.control))
-    func `[control] string bs`() throws {
+    @Test("[control] string bs", .tags(.control))
+    func control__string_bs() throws {
         try invalidate(pathComponents: ["control", "string-bs"])
     }
 
-    @Test(.tags(.control))
-    func `[control] string cr`() throws {
+    @Test("[control] string cr", .tags(.control))
+    func control__string_cr() throws {
         try invalidate(pathComponents: ["control", "string-cr"])
     }
 
-    @Test(.tags(.control))
-    func `[control] string del`() throws {
+    @Test("[control] string del", .tags(.control))
+    func control__string_del() throws {
         try invalidate(pathComponents: ["control", "string-del"])
     }
 
-    @Test(.tags(.control))
-    func `[control] string lf`() throws {
+    @Test("[control] string lf", .tags(.control))
+    func control__string_lf() throws {
         try invalidate(pathComponents: ["control", "string-lf"])
     }
 
-    @Test(.tags(.control))
-    func `[control] string null`() throws {
+    @Test("[control] string null", .tags(.control))
+    func control__string_null() throws {
         try invalidate(pathComponents: ["control", "string-null"])
     }
 
-    @Test(.tags(.control))
-    func `[control] string us`() throws {
+    @Test("[control] string us", .tags(.control))
+    func control__string_us() throws {
         try invalidate(pathComponents: ["control", "string-us"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] day zero`() throws {
+    @Test("[datetime] day zero", .tags(.datetime))
+    func datetime__day_zero() throws {
         try invalidate(pathComponents: ["datetime", "day-zero"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] feb 29`() throws {
+    @Test("[datetime] feb 29", .tags(.datetime))
+    func datetime__feb_29() throws {
         try invalidate(pathComponents: ["datetime", "feb-29"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] feb 30`() throws {
+    @Test("[datetime] feb 30", .tags(.datetime))
+    func datetime__feb_30() throws {
         try invalidate(pathComponents: ["datetime", "feb-30"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] hour over`() throws {
+    @Test("[datetime] hour over", .tags(.datetime))
+    func datetime__hour_over() throws {
         try invalidate(pathComponents: ["datetime", "hour-over"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] mday over`() throws {
+    @Test("[datetime] mday over", .tags(.datetime))
+    func datetime__mday_over() throws {
         try invalidate(pathComponents: ["datetime", "mday-over"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] mday under`() throws {
+    @Test("[datetime] mday under", .tags(.datetime))
+    func datetime__mday_under() throws {
         try invalidate(pathComponents: ["datetime", "mday-under"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] minute over`() throws {
+    @Test("[datetime] minute over", .tags(.datetime))
+    func datetime__minute_over() throws {
         try invalidate(pathComponents: ["datetime", "minute-over"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] month over`() throws {
+    @Test("[datetime] month over", .tags(.datetime))
+    func datetime__month_over() throws {
         try invalidate(pathComponents: ["datetime", "month-over"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] month under`() throws {
+    @Test("[datetime] month under", .tags(.datetime))
+    func datetime__month_under() throws {
         try invalidate(pathComponents: ["datetime", "month-under"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] no date time sep`() throws {
+    @Test("[datetime] no date time sep", .tags(.datetime))
+    func datetime__no_date_time_sep() throws {
         try invalidate(pathComponents: ["datetime", "no-date-time-sep"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] no leads`() throws {
+    @Test("[datetime] no leads", .tags(.datetime))
+    func datetime__no_leads() throws {
         try invalidate(pathComponents: ["datetime", "no-leads"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] no leads month`() throws {
+    @Test("[datetime] no leads month", .tags(.datetime))
+    func datetime__no_leads_month() throws {
         try invalidate(pathComponents: ["datetime", "no-leads-month"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] no leads with milli`() throws {
+    @Test("[datetime] no leads with milli", .tags(.datetime))
+    func datetime__no_leads_with_milli() throws {
         try invalidate(pathComponents: ["datetime", "no-leads-with-milli"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] no t`() throws {
+    @Test("[datetime] no t", .tags(.datetime))
+    func datetime__no_t() throws {
         try invalidate(pathComponents: ["datetime", "no-t"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] no year month sep`() throws {
+    @Test("[datetime] no year month sep", .tags(.datetime))
+    func datetime__no_year_month_sep() throws {
         try invalidate(pathComponents: ["datetime", "no-year-month-sep"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] offset minus minute 1digit`() throws {
+    @Test("[datetime] offset minus minute 1digit", .tags(.datetime))
+    func datetime__offset_minus_minute_1digit() throws {
         try invalidate(pathComponents: ["datetime", "offset-minus-minute-1digit"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] offset minus no hour minute`() throws {
+    @Test("[datetime] offset minus no hour minute", .tags(.datetime))
+    func datetime__offset_minus_no_hour_minute() throws {
         try invalidate(pathComponents: ["datetime", "offset-minus-no-hour-minute"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] offset minus no hour minute sep`() throws {
+    @Test("[datetime] offset minus no hour minute sep", .tags(.datetime))
+    func datetime__offset_minus_no_hour_minute_sep() throws {
         try invalidate(pathComponents: ["datetime", "offset-minus-no-hour-minute-sep"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] offset minus no minute`() throws {
+    @Test("[datetime] offset minus no minute", .tags(.datetime))
+    func datetime__offset_minus_no_minute() throws {
         try invalidate(pathComponents: ["datetime", "offset-minus-no-minute"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] offset overflow hour`() throws {
+    @Test("[datetime] offset overflow hour", .tags(.datetime))
+    func datetime__offset_overflow_hour() throws {
         try invalidate(pathComponents: ["datetime", "offset-overflow-hour"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] offset overflow minute`() throws {
+    @Test("[datetime] offset overflow minute", .tags(.datetime))
+    func datetime__offset_overflow_minute() throws {
         try invalidate(pathComponents: ["datetime", "offset-overflow-minute"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] offset plus minute 1digit`() throws {
+    @Test("[datetime] offset plus minute 1digit", .tags(.datetime))
+    func datetime__offset_plus_minute_1digit() throws {
         try invalidate(pathComponents: ["datetime", "offset-plus-minute-1digit"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] offset plus no hour minute`() throws {
+    @Test("[datetime] offset plus no hour minute", .tags(.datetime))
+    func datetime__offset_plus_no_hour_minute() throws {
         try invalidate(pathComponents: ["datetime", "offset-plus-no-hour-minute"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] offset plus no hour minute sep`() throws {
+    @Test("[datetime] offset plus no hour minute sep", .tags(.datetime))
+    func datetime__offset_plus_no_hour_minute_sep() throws {
         try invalidate(pathComponents: ["datetime", "offset-plus-no-hour-minute-sep"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] offset plus no minute`() throws {
+    @Test("[datetime] offset plus no minute", .tags(.datetime))
+    func datetime__offset_plus_no_minute() throws {
         try invalidate(pathComponents: ["datetime", "offset-plus-no-minute"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] only T`() throws {
+    @Test("[datetime] only T", .tags(.datetime))
+    func datetime__only_T() throws {
         try invalidate(pathComponents: ["datetime", "only-T"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] only TZ`() throws {
+    @Test("[datetime] only TZ", .tags(.datetime))
+    func datetime__only_TZ() throws {
         try invalidate(pathComponents: ["datetime", "only-TZ"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] only Tdot`() throws {
+    @Test("[datetime] only Tdot", .tags(.datetime))
+    func datetime__only_Tdot() throws {
         try invalidate(pathComponents: ["datetime", "only-Tdot"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] second over`() throws {
+    @Test("[datetime] second over", .tags(.datetime))
+    func datetime__second_over() throws {
         try invalidate(pathComponents: ["datetime", "second-over"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] second trailing dot`() throws {
+    @Test("[datetime] second trailing dot", .tags(.datetime))
+    func datetime__second_trailing_dot() throws {
         try invalidate(pathComponents: ["datetime", "second-trailing-dot"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] second trailing dotz`() throws {
+    @Test("[datetime] second trailing dotz", .tags(.datetime))
+    func datetime__second_trailing_dotz() throws {
         try invalidate(pathComponents: ["datetime", "second-trailing-dotz"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] time no leads`() throws {
+    @Test("[datetime] time no leads", .tags(.datetime))
+    func datetime__time_no_leads() throws {
         try invalidate(pathComponents: ["datetime", "time-no-leads"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] trailing x`() throws {
+    @Test("[datetime] trailing x", .tags(.datetime))
+    func datetime__trailing_x() throws {
         try invalidate(pathComponents: ["datetime", "trailing-x"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] y10k`() throws {
+    @Test("[datetime] y10k", .tags(.datetime))
+    func datetime__y10k() throws {
         try invalidate(pathComponents: ["datetime", "y10k"])
     }
 
-    @Test(.tags(.encoding))
-    func `[encoding] bad codepoint`() throws {
+    @Test("[encoding] bad codepoint", .tags(.encoding))
+    func encoding__bad_codepoint() throws {
         try invalidate(pathComponents: ["encoding", "bad-codepoint"])
     }
 
-    @Test(.tags(.encoding))
-    func `[encoding] bad utf8 at end`() throws {
+    @Test("[encoding] bad utf8 at end", .tags(.encoding))
+    func encoding__bad_utf8_at_end() throws {
         try invalidate(pathComponents: ["encoding", "bad-utf8-at-end"])
     }
 
-    @Test(.tags(.encoding))
-    func `[encoding] bad utf8 in array`() throws {
+    @Test("[encoding] bad utf8 in array", .tags(.encoding))
+    func encoding__bad_utf8_in_array() throws {
         try invalidate(pathComponents: ["encoding", "bad-utf8-in-array"])
     }
 
-    @Test(.tags(.encoding))
-    func `[encoding] bad utf8 in comment`() throws {
+    @Test("[encoding] bad utf8 in comment", .tags(.encoding))
+    func encoding__bad_utf8_in_comment() throws {
         try invalidate(pathComponents: ["encoding", "bad-utf8-in-comment"])
     }
 
-    @Test(.tags(.encoding))
-    func `[encoding] bad utf8 in multiline`() throws {
+    @Test("[encoding] bad utf8 in multiline", .tags(.encoding))
+    func encoding__bad_utf8_in_multiline() throws {
         try invalidate(pathComponents: ["encoding", "bad-utf8-in-multiline"])
     }
 
-    @Test(.tags(.encoding))
-    func `[encoding] bad utf8 in multiline literal`() throws {
+    @Test("[encoding] bad utf8 in multiline literal", .tags(.encoding))
+    func encoding__bad_utf8_in_multiline_literal() throws {
         try invalidate(pathComponents: ["encoding", "bad-utf8-in-multiline-literal"])
     }
 
-    @Test(.tags(.encoding))
-    func `[encoding] bad utf8 in string`() throws {
+    @Test("[encoding] bad utf8 in string", .tags(.encoding))
+    func encoding__bad_utf8_in_string() throws {
         try invalidate(pathComponents: ["encoding", "bad-utf8-in-string"])
     }
 
-    @Test(.tags(.encoding))
-    func `[encoding] bad utf8 in string literal`() throws {
+    @Test("[encoding] bad utf8 in string literal", .tags(.encoding))
+    func encoding__bad_utf8_in_string_literal() throws {
         try invalidate(pathComponents: ["encoding", "bad-utf8-in-string-literal"])
     }
 
-    @Test(.tags(.encoding))
-    func `[encoding] bom not at start 01`() throws {
+    @Test("[encoding] bom not at start 01", .tags(.encoding))
+    func encoding__bom_not_at_start_01() throws {
         try invalidate(pathComponents: ["encoding", "bom-not-at-start-01"])
     }
 
-    @Test(.tags(.encoding))
-    func `[encoding] bom not at start 02`() throws {
+    @Test("[encoding] bom not at start 02", .tags(.encoding))
+    func encoding__bom_not_at_start_02() throws {
         try invalidate(pathComponents: ["encoding", "bom-not-at-start-02"])
     }
 
-    @Test(.tags(.encoding))
-    func `[encoding] ideographic space`() throws {
+    @Test("[encoding] ideographic space", .tags(.encoding))
+    func encoding__ideographic_space() throws {
         try invalidate(pathComponents: ["encoding", "ideographic-space"])
     }
 
-    @Test(.tags(.encoding))
-    func `[encoding] utf16 bom`() throws {
+    @Test("[encoding] utf16 bom", .tags(.encoding))
+    func encoding__utf16_bom() throws {
         try invalidate(pathComponents: ["encoding", "utf16-bom"])
     }
 
-    @Test(.tags(.encoding))
-    func `[encoding] utf16 comment`() throws {
+    @Test("[encoding] utf16 comment", .tags(.encoding))
+    func encoding__utf16_comment() throws {
         try invalidate(pathComponents: ["encoding", "utf16-comment"])
     }
 
-    @Test(.tags(.encoding))
-    func `[encoding] utf16 key`() throws {
+    @Test("[encoding] utf16 key", .tags(.encoding))
+    func encoding__utf16_key() throws {
         try invalidate(pathComponents: ["encoding", "utf16-key"])
     }
 
-    @Test(.tags(.float))
-    func `[float] double dot 01`() throws {
+    @Test("[float] double dot 01", .tags(.float))
+    func float__double_dot_01() throws {
         try invalidate(pathComponents: ["float", "double-dot-01"])
     }
 
-    @Test(.tags(.float))
-    func `[float] double dot 02`() throws {
+    @Test("[float] double dot 02", .tags(.float))
+    func float__double_dot_02() throws {
         try invalidate(pathComponents: ["float", "double-dot-02"])
     }
 
-    @Test(.tags(.float))
-    func `[float] exp dot 01`() throws {
+    @Test("[float] exp dot 01", .tags(.float))
+    func float__exp_dot_01() throws {
         try invalidate(pathComponents: ["float", "exp-dot-01"])
     }
 
-    @Test(.tags(.float))
-    func `[float] exp dot 02`() throws {
+    @Test("[float] exp dot 02", .tags(.float))
+    func float__exp_dot_02() throws {
         try invalidate(pathComponents: ["float", "exp-dot-02"])
     }
 
-    @Test(.tags(.float))
-    func `[float] exp dot 03`() throws {
+    @Test("[float] exp dot 03", .tags(.float))
+    func float__exp_dot_03() throws {
         try invalidate(pathComponents: ["float", "exp-dot-03"])
     }
 
-    @Test(.tags(.float))
-    func `[float] exp double e 01`() throws {
+    @Test("[float] exp double e 01", .tags(.float))
+    func float__exp_double_e_01() throws {
         try invalidate(pathComponents: ["float", "exp-double-e-01"])
     }
 
-    @Test(.tags(.float))
-    func `[float] exp double e 02`() throws {
+    @Test("[float] exp double e 02", .tags(.float))
+    func float__exp_double_e_02() throws {
         try invalidate(pathComponents: ["float", "exp-double-e-02"])
     }
 
-    @Test(.tags(.float))
-    func `[float] exp double us`() throws {
+    @Test("[float] exp double us", .tags(.float))
+    func float__exp_double_us() throws {
         try invalidate(pathComponents: ["float", "exp-double-us"])
     }
 
-    @Test(.tags(.float))
-    func `[float] exp leading us`() throws {
+    @Test("[float] exp leading us", .tags(.float))
+    func float__exp_leading_us() throws {
         try invalidate(pathComponents: ["float", "exp-leading-us"])
     }
 
-    @Test(.tags(.float))
-    func `[float] exp trailing us`() throws {
+    @Test("[float] exp trailing us", .tags(.float))
+    func float__exp_trailing_us() throws {
         try invalidate(pathComponents: ["float", "exp-trailing-us"])
     }
 
-    @Test(.tags(.float))
-    func `[float] exp trailing us 01`() throws {
+    @Test("[float] exp trailing us 01", .tags(.float))
+    func float__exp_trailing_us_01() throws {
         try invalidate(pathComponents: ["float", "exp-trailing-us-01"])
     }
 
-    @Test(.tags(.float))
-    func `[float] exp trailing us 02`() throws {
+    @Test("[float] exp trailing us 02", .tags(.float))
+    func float__exp_trailing_us_02() throws {
         try invalidate(pathComponents: ["float", "exp-trailing-us-02"])
     }
 
-    @Test(.tags(.float))
-    func `[float] inf capital`() throws {
+    @Test("[float] inf capital", .tags(.float))
+    func float__inf_capital() throws {
         try invalidate(pathComponents: ["float", "inf-capital"])
     }
 
-    @Test(.tags(.float))
-    func `[float] inf incomplete 01`() throws {
+    @Test("[float] inf incomplete 01", .tags(.float))
+    func float__inf_incomplete_01() throws {
         try invalidate(pathComponents: ["float", "inf-incomplete-01"])
     }
 
-    @Test(.tags(.float))
-    func `[float] inf incomplete 02`() throws {
+    @Test("[float] inf incomplete 02", .tags(.float))
+    func float__inf_incomplete_02() throws {
         try invalidate(pathComponents: ["float", "inf-incomplete-02"])
     }
 
-    @Test(.tags(.float))
-    func `[float] inf incomplete 03`() throws {
+    @Test("[float] inf incomplete 03", .tags(.float))
+    func float__inf_incomplete_03() throws {
         try invalidate(pathComponents: ["float", "inf-incomplete-03"])
     }
 
-    @Test(.tags(.float))
-    func `[float] inf underscore`() throws {
+    @Test("[float] inf underscore", .tags(.float))
+    func float__inf_underscore() throws {
         try invalidate(pathComponents: ["float", "inf_underscore"])
     }
 
-    @Test(.tags(.float))
-    func `[float] leading dot`() throws {
+    @Test("[float] leading dot", .tags(.float))
+    func float__leading_dot() throws {
         try invalidate(pathComponents: ["float", "leading-dot"])
     }
 
-    @Test(.tags(.float))
-    func `[float] leading dot neg`() throws {
+    @Test("[float] leading dot neg", .tags(.float))
+    func float__leading_dot_neg() throws {
         try invalidate(pathComponents: ["float", "leading-dot-neg"])
     }
 
-    @Test(.tags(.float))
-    func `[float] leading dot plus`() throws {
+    @Test("[float] leading dot plus", .tags(.float))
+    func float__leading_dot_plus() throws {
         try invalidate(pathComponents: ["float", "leading-dot-plus"])
     }
 
-    @Test(.tags(.float))
-    func `[float] leading us`() throws {
+    @Test("[float] leading us", .tags(.float))
+    func float__leading_us() throws {
         try invalidate(pathComponents: ["float", "leading-us"])
     }
 
-    @Test(.tags(.float))
-    func `[float] leading zero`() throws {
+    @Test("[float] leading zero", .tags(.float))
+    func float__leading_zero() throws {
         try invalidate(pathComponents: ["float", "leading-zero"])
     }
 
-    @Test(.tags(.float))
-    func `[float] leading zero neg`() throws {
+    @Test("[float] leading zero neg", .tags(.float))
+    func float__leading_zero_neg() throws {
         try invalidate(pathComponents: ["float", "leading-zero-neg"])
     }
 
-    @Test(.tags(.float))
-    func `[float] leading zero plus`() throws {
+    @Test("[float] leading zero plus", .tags(.float))
+    func float__leading_zero_plus() throws {
         try invalidate(pathComponents: ["float", "leading-zero-plus"])
     }
 
-    @Test(.tags(.float))
-    func `[float] nan capital`() throws {
+    @Test("[float] nan capital", .tags(.float))
+    func float__nan_capital() throws {
         try invalidate(pathComponents: ["float", "nan-capital"])
     }
 
-    @Test(.tags(.float))
-    func `[float] nan incomplete 01`() throws {
+    @Test("[float] nan incomplete 01", .tags(.float))
+    func float__nan_incomplete_01() throws {
         try invalidate(pathComponents: ["float", "nan-incomplete-01"])
     }
 
-    @Test(.tags(.float))
-    func `[float] nan incomplete 02`() throws {
+    @Test("[float] nan incomplete 02", .tags(.float))
+    func float__nan_incomplete_02() throws {
         try invalidate(pathComponents: ["float", "nan-incomplete-02"])
     }
 
-    @Test(.tags(.float))
-    func `[float] nan incomplete 03`() throws {
+    @Test("[float] nan incomplete 03", .tags(.float))
+    func float__nan_incomplete_03() throws {
         try invalidate(pathComponents: ["float", "nan-incomplete-03"])
     }
 
-    @Test(.tags(.float))
-    func `[float] nan underscore`() throws {
+    @Test("[float] nan underscore", .tags(.float))
+    func float__nan_underscore() throws {
         try invalidate(pathComponents: ["float", "nan_underscore"])
     }
 
-    @Test(.tags(.float))
-    func `[float] trailing dot`() throws {
+    @Test("[float] trailing dot", .tags(.float))
+    func float__trailing_dot() throws {
         try invalidate(pathComponents: ["float", "trailing-dot"])
     }
 
-    @Test(.tags(.float))
-    func `[float] trailing dot 01`() throws {
+    @Test("[float] trailing dot 01", .tags(.float))
+    func float__trailing_dot_01() throws {
         try invalidate(pathComponents: ["float", "trailing-dot-01"])
     }
 
-    @Test(.tags(.float))
-    func `[float] trailing dot 02`() throws {
+    @Test("[float] trailing dot 02", .tags(.float))
+    func float__trailing_dot_02() throws {
         try invalidate(pathComponents: ["float", "trailing-dot-02"])
     }
 
-    @Test(.tags(.float))
-    func `[float] trailing dot min`() throws {
+    @Test("[float] trailing dot min", .tags(.float))
+    func float__trailing_dot_min() throws {
         try invalidate(pathComponents: ["float", "trailing-dot-min"])
     }
 
-    @Test(.tags(.float))
-    func `[float] trailing dot plus`() throws {
+    @Test("[float] trailing dot plus", .tags(.float))
+    func float__trailing_dot_plus() throws {
         try invalidate(pathComponents: ["float", "trailing-dot-plus"])
     }
 
-    @Test(.tags(.float))
-    func `[float] trailing exp`() throws {
+    @Test("[float] trailing exp", .tags(.float))
+    func float__trailing_exp() throws {
         try invalidate(pathComponents: ["float", "trailing-exp"])
     }
 
-    @Test(.tags(.float))
-    func `[float] trailing exp dot`() throws {
+    @Test("[float] trailing exp dot", .tags(.float))
+    func float__trailing_exp_dot() throws {
         try invalidate(pathComponents: ["float", "trailing-exp-dot"])
     }
 
-    @Test(.tags(.float))
-    func `[float] trailing exp minus`() throws {
+    @Test("[float] trailing exp minus", .tags(.float))
+    func float__trailing_exp_minus() throws {
         try invalidate(pathComponents: ["float", "trailing-exp-minus"])
     }
 
-    @Test(.tags(.float))
-    func `[float] trailing exp plus`() throws {
+    @Test("[float] trailing exp plus", .tags(.float))
+    func float__trailing_exp_plus() throws {
         try invalidate(pathComponents: ["float", "trailing-exp-plus"])
     }
 
-    @Test(.tags(.float))
-    func `[float] trailing us`() throws {
+    @Test("[float] trailing us", .tags(.float))
+    func float__trailing_us() throws {
         try invalidate(pathComponents: ["float", "trailing-us"])
     }
 
-    @Test(.tags(.float))
-    func `[float] trailing us exp 01`() throws {
+    @Test("[float] trailing us exp 01", .tags(.float))
+    func float__trailing_us_exp_01() throws {
         try invalidate(pathComponents: ["float", "trailing-us-exp-01"])
     }
 
-    @Test(.tags(.float))
-    func `[float] trailing us exp 02`() throws {
+    @Test("[float] trailing us exp 02", .tags(.float))
+    func float__trailing_us_exp_02() throws {
         try invalidate(pathComponents: ["float", "trailing-us-exp-02"])
     }
 
-    @Test(.tags(.float))
-    func `[float] us after dot`() throws {
+    @Test("[float] us after dot", .tags(.float))
+    func float__us_after_dot() throws {
         try invalidate(pathComponents: ["float", "us-after-dot"])
     }
 
-    @Test(.tags(.float))
-    func `[float] us before dot`() throws {
+    @Test("[float] us before dot", .tags(.float))
+    func float__us_before_dot() throws {
         try invalidate(pathComponents: ["float", "us-before-dot"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] bad key syntax`() throws {
+    @Test("[inline-table] bad key syntax", .tags(.inline_table))
+    func inline_table__bad_key_syntax() throws {
         try invalidate(pathComponents: ["inline-table", "bad-key-syntax"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] double comma`() throws {
+    @Test("[inline-table] double comma", .tags(.inline_table))
+    func inline_table__double_comma() throws {
         try invalidate(pathComponents: ["inline-table", "double-comma"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] duplicate key 01`() throws {
+    @Test("[inline-table] duplicate key 01", .tags(.inline_table))
+    func inline_table__duplicate_key_01() throws {
         try invalidate(pathComponents: ["inline-table", "duplicate-key-01"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] duplicate key 02`() throws {
+    @Test("[inline-table] duplicate key 02", .tags(.inline_table))
+    func inline_table__duplicate_key_02() throws {
         try invalidate(pathComponents: ["inline-table", "duplicate-key-02"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] duplicate key 03`() throws {
+    @Test("[inline-table] duplicate key 03", .tags(.inline_table))
+    func inline_table__duplicate_key_03() throws {
         try invalidate(pathComponents: ["inline-table", "duplicate-key-03"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] duplicate key 04`() throws {
+    @Test("[inline-table] duplicate key 04", .tags(.inline_table))
+    func inline_table__duplicate_key_04() throws {
         try invalidate(pathComponents: ["inline-table", "duplicate-key-04"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] empty 01`() throws {
+    @Test("[inline-table] empty 01", .tags(.inline_table))
+    func inline_table__empty_01() throws {
         try invalidate(pathComponents: ["inline-table", "empty-01"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] empty 02`() throws {
+    @Test("[inline-table] empty 02", .tags(.inline_table))
+    func inline_table__empty_02() throws {
         try invalidate(pathComponents: ["inline-table", "empty-02"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] empty 03`() throws {
+    @Test("[inline-table] empty 03", .tags(.inline_table))
+    func inline_table__empty_03() throws {
         try invalidate(pathComponents: ["inline-table", "empty-03"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] no close 01`() throws {
+    @Test("[inline-table] no close 01", .tags(.inline_table))
+    func inline_table__no_close_01() throws {
         try invalidate(pathComponents: ["inline-table", "no-close-01"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] no close 02`() throws {
+    @Test("[inline-table] no close 02", .tags(.inline_table))
+    func inline_table__no_close_02() throws {
         try invalidate(pathComponents: ["inline-table", "no-close-02"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] no comma 01`() throws {
+    @Test("[inline-table] no comma 01", .tags(.inline_table))
+    func inline_table__no_comma_01() throws {
         try invalidate(pathComponents: ["inline-table", "no-comma-01"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] no comma 02`() throws {
+    @Test("[inline-table] no comma 02", .tags(.inline_table))
+    func inline_table__no_comma_02() throws {
         try invalidate(pathComponents: ["inline-table", "no-comma-02"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] overwrite 01`() throws {
+    @Test("[inline-table] overwrite 01", .tags(.inline_table))
+    func inline_table__overwrite_01() throws {
         try invalidate(pathComponents: ["inline-table", "overwrite-01"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] overwrite 02`() throws {
+    @Test("[inline-table] overwrite 02", .tags(.inline_table))
+    func inline_table__overwrite_02() throws {
         try invalidate(pathComponents: ["inline-table", "overwrite-02"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] overwrite 03`() throws {
+    @Test("[inline-table] overwrite 03", .tags(.inline_table))
+    func inline_table__overwrite_03() throws {
         try invalidate(pathComponents: ["inline-table", "overwrite-03"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] overwrite 04`() throws {
+    @Test("[inline-table] overwrite 04", .tags(.inline_table))
+    func inline_table__overwrite_04() throws {
         try invalidate(pathComponents: ["inline-table", "overwrite-04"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] overwrite 05`() throws {
+    @Test("[inline-table] overwrite 05", .tags(.inline_table))
+    func inline_table__overwrite_05() throws {
         try invalidate(pathComponents: ["inline-table", "overwrite-05"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] overwrite 06`() throws {
+    @Test("[inline-table] overwrite 06", .tags(.inline_table))
+    func inline_table__overwrite_06() throws {
         try invalidate(pathComponents: ["inline-table", "overwrite-06"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] overwrite 07`() throws {
+    @Test("[inline-table] overwrite 07", .tags(.inline_table))
+    func inline_table__overwrite_07() throws {
         try invalidate(pathComponents: ["inline-table", "overwrite-07"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] overwrite 08`() throws {
+    @Test("[inline-table] overwrite 08", .tags(.inline_table))
+    func inline_table__overwrite_08() throws {
         try invalidate(pathComponents: ["inline-table", "overwrite-08"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] overwrite 09`() throws {
+    @Test("[inline-table] overwrite 09", .tags(.inline_table))
+    func inline_table__overwrite_09() throws {
         try invalidate(pathComponents: ["inline-table", "overwrite-09"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] overwrite 10`() throws {
+    @Test("[inline-table] overwrite 10", .tags(.inline_table))
+    func inline_table__overwrite_10() throws {
         try invalidate(pathComponents: ["inline-table", "overwrite-10"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] capital bin`() throws {
+    @Test("[integer] capital bin", .tags(.integer))
+    func integer__capital_bin() throws {
         try invalidate(pathComponents: ["integer", "capital-bin"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] capital hex`() throws {
+    @Test("[integer] capital hex", .tags(.integer))
+    func integer__capital_hex() throws {
         try invalidate(pathComponents: ["integer", "capital-hex"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] capital oct`() throws {
+    @Test("[integer] capital oct", .tags(.integer))
+    func integer__capital_oct() throws {
         try invalidate(pathComponents: ["integer", "capital-oct"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] double sign nex`() throws {
+    @Test("[integer] double sign nex", .tags(.integer))
+    func integer__double_sign_nex() throws {
         try invalidate(pathComponents: ["integer", "double-sign-nex"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] double sign plus`() throws {
+    @Test("[integer] double sign plus", .tags(.integer))
+    func integer__double_sign_plus() throws {
         try invalidate(pathComponents: ["integer", "double-sign-plus"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] double us`() throws {
+    @Test("[integer] double us", .tags(.integer))
+    func integer__double_us() throws {
         try invalidate(pathComponents: ["integer", "double-us"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] incomplete bin`() throws {
+    @Test("[integer] incomplete bin", .tags(.integer))
+    func integer__incomplete_bin() throws {
         try invalidate(pathComponents: ["integer", "incomplete-bin"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] incomplete hex`() throws {
+    @Test("[integer] incomplete hex", .tags(.integer))
+    func integer__incomplete_hex() throws {
         try invalidate(pathComponents: ["integer", "incomplete-hex"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] incomplete oct`() throws {
+    @Test("[integer] incomplete oct", .tags(.integer))
+    func integer__incomplete_oct() throws {
         try invalidate(pathComponents: ["integer", "incomplete-oct"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] invalid bin`() throws {
+    @Test("[integer] invalid bin", .tags(.integer))
+    func integer__invalid_bin() throws {
         try invalidate(pathComponents: ["integer", "invalid-bin"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] invalid hex 01`() throws {
+    @Test("[integer] invalid hex 01", .tags(.integer))
+    func integer__invalid_hex_01() throws {
         try invalidate(pathComponents: ["integer", "invalid-hex-01"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] invalid hex 02`() throws {
+    @Test("[integer] invalid hex 02", .tags(.integer))
+    func integer__invalid_hex_02() throws {
         try invalidate(pathComponents: ["integer", "invalid-hex-02"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] invalid hex 03`() throws {
+    @Test("[integer] invalid hex 03", .tags(.integer))
+    func integer__invalid_hex_03() throws {
         try invalidate(pathComponents: ["integer", "invalid-hex-03"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] invalid oct`() throws {
+    @Test("[integer] invalid oct", .tags(.integer))
+    func integer__invalid_oct() throws {
         try invalidate(pathComponents: ["integer", "invalid-oct"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] leading us`() throws {
+    @Test("[integer] leading us", .tags(.integer))
+    func integer__leading_us() throws {
         try invalidate(pathComponents: ["integer", "leading-us"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] leading us bin`() throws {
+    @Test("[integer] leading us bin", .tags(.integer))
+    func integer__leading_us_bin() throws {
         try invalidate(pathComponents: ["integer", "leading-us-bin"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] leading us hex`() throws {
+    @Test("[integer] leading us hex", .tags(.integer))
+    func integer__leading_us_hex() throws {
         try invalidate(pathComponents: ["integer", "leading-us-hex"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] leading us oct`() throws {
+    @Test("[integer] leading us oct", .tags(.integer))
+    func integer__leading_us_oct() throws {
         try invalidate(pathComponents: ["integer", "leading-us-oct"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] leading zero 01`() throws {
+    @Test("[integer] leading zero 01", .tags(.integer))
+    func integer__leading_zero_01() throws {
         try invalidate(pathComponents: ["integer", "leading-zero-01"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] leading zero 02`() throws {
+    @Test("[integer] leading zero 02", .tags(.integer))
+    func integer__leading_zero_02() throws {
         try invalidate(pathComponents: ["integer", "leading-zero-02"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] leading zero 03`() throws {
+    @Test("[integer] leading zero 03", .tags(.integer))
+    func integer__leading_zero_03() throws {
         try invalidate(pathComponents: ["integer", "leading-zero-03"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] leading zero sign 01`() throws {
+    @Test("[integer] leading zero sign 01", .tags(.integer))
+    func integer__leading_zero_sign_01() throws {
         try invalidate(pathComponents: ["integer", "leading-zero-sign-01"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] leading zero sign 02`() throws {
+    @Test("[integer] leading zero sign 02", .tags(.integer))
+    func integer__leading_zero_sign_02() throws {
         try invalidate(pathComponents: ["integer", "leading-zero-sign-02"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] leading zero sign 03`() throws {
+    @Test("[integer] leading zero sign 03", .tags(.integer))
+    func integer__leading_zero_sign_03() throws {
         try invalidate(pathComponents: ["integer", "leading-zero-sign-03"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] negative bin`() throws {
+    @Test("[integer] negative bin", .tags(.integer))
+    func integer__negative_bin() throws {
         try invalidate(pathComponents: ["integer", "negative-bin"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] negative hex`() throws {
+    @Test("[integer] negative hex", .tags(.integer))
+    func integer__negative_hex() throws {
         try invalidate(pathComponents: ["integer", "negative-hex"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] negative oct`() throws {
+    @Test("[integer] negative oct", .tags(.integer))
+    func integer__negative_oct() throws {
         try invalidate(pathComponents: ["integer", "negative-oct"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] positive bin`() throws {
+    @Test("[integer] positive bin", .tags(.integer))
+    func integer__positive_bin() throws {
         try invalidate(pathComponents: ["integer", "positive-bin"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] positive hex`() throws {
+    @Test("[integer] positive hex", .tags(.integer))
+    func integer__positive_hex() throws {
         try invalidate(pathComponents: ["integer", "positive-hex"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] positive oct`() throws {
+    @Test("[integer] positive oct", .tags(.integer))
+    func integer__positive_oct() throws {
         try invalidate(pathComponents: ["integer", "positive-oct"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] text after integer`() throws {
+    @Test("[integer] text after integer", .tags(.integer))
+    func integer__text_after_integer() throws {
         try invalidate(pathComponents: ["integer", "text-after-integer"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] trailing us`() throws {
+    @Test("[integer] trailing us", .tags(.integer))
+    func integer__trailing_us() throws {
         try invalidate(pathComponents: ["integer", "trailing-us"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] trailing us bin`() throws {
+    @Test("[integer] trailing us bin", .tags(.integer))
+    func integer__trailing_us_bin() throws {
         try invalidate(pathComponents: ["integer", "trailing-us-bin"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] trailing us hex`() throws {
+    @Test("[integer] trailing us hex", .tags(.integer))
+    func integer__trailing_us_hex() throws {
         try invalidate(pathComponents: ["integer", "trailing-us-hex"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] trailing us oct`() throws {
+    @Test("[integer] trailing us oct", .tags(.integer))
+    func integer__trailing_us_oct() throws {
         try invalidate(pathComponents: ["integer", "trailing-us-oct"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] us after bin`() throws {
+    @Test("[integer] us after bin", .tags(.integer))
+    func integer__us_after_bin() throws {
         try invalidate(pathComponents: ["integer", "us-after-bin"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] us after hex`() throws {
+    @Test("[integer] us after hex", .tags(.integer))
+    func integer__us_after_hex() throws {
         try invalidate(pathComponents: ["integer", "us-after-hex"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] us after oct`() throws {
+    @Test("[integer] us after oct", .tags(.integer))
+    func integer__us_after_oct() throws {
         try invalidate(pathComponents: ["integer", "us-after-oct"])
     }
 
-    @Test(.tags(.key))
-    func `[key] after array`() throws {
+    @Test("[key] after array", .tags(.key))
+    func key__after_array() throws {
         try invalidate(pathComponents: ["key", "after-array"])
     }
 
-    @Test(.tags(.key))
-    func `[key] after table`() throws {
+    @Test("[key] after table", .tags(.key))
+    func key__after_table() throws {
         try invalidate(pathComponents: ["key", "after-table"])
     }
 
-    @Test(.tags(.key))
-    func `[key] after value`() throws {
+    @Test("[key] after value", .tags(.key))
+    func key__after_value() throws {
         try invalidate(pathComponents: ["key", "after-value"])
     }
 
-    @Test(.tags(.key))
-    func `[key] bare invalid character 01`() throws {
+    @Test("[key] bare invalid character 01", .tags(.key))
+    func key__bare_invalid_character_01() throws {
         try invalidate(pathComponents: ["key", "bare-invalid-character-01"])
     }
 
-    @Test(.tags(.key))
-    func `[key] bare invalid character 02`() throws {
+    @Test("[key] bare invalid character 02", .tags(.key))
+    func key__bare_invalid_character_02() throws {
         try invalidate(pathComponents: ["key", "bare-invalid-character-02"])
     }
 
-    @Test(.tags(.key))
-    func `[key] dot`() throws {
+    @Test("[key] dot", .tags(.key))
+    func key__dot() throws {
         try invalidate(pathComponents: ["key", "dot"])
     }
 
-    @Test(.tags(.key))
-    func `[key] dotdot`() throws {
+    @Test("[key] dotdot", .tags(.key))
+    func key__dotdot() throws {
         try invalidate(pathComponents: ["key", "dotdot"])
     }
 
-    @Test(.tags(.key))
-    func `[key] dotted redefine table 01`() throws {
+    @Test("[key] dotted redefine table 01", .tags(.key))
+    func key__dotted_redefine_table_01() throws {
         try invalidate(pathComponents: ["key", "dotted-redefine-table-01"])
     }
 
-    @Test(.tags(.key))
-    func `[key] dotted redefine table 02`() throws {
+    @Test("[key] dotted redefine table 02", .tags(.key))
+    func key__dotted_redefine_table_02() throws {
         try invalidate(pathComponents: ["key", "dotted-redefine-table-02"])
     }
 
-    @Test(.tags(.key))
-    func `[key] duplicate keys 01`() throws {
+    @Test("[key] duplicate keys 01", .tags(.key))
+    func key__duplicate_keys_01() throws {
         try invalidate(pathComponents: ["key", "duplicate-keys-01"])
     }
 
-    @Test(.tags(.key))
-    func `[key] duplicate keys 02`() throws {
+    @Test("[key] duplicate keys 02", .tags(.key))
+    func key__duplicate_keys_02() throws {
         try invalidate(pathComponents: ["key", "duplicate-keys-02"])
     }
 
-    @Test(.tags(.key))
-    func `[key] duplicate keys 03`() throws {
+    @Test("[key] duplicate keys 03", .tags(.key))
+    func key__duplicate_keys_03() throws {
         try invalidate(pathComponents: ["key", "duplicate-keys-03"])
     }
 
-    @Test(.tags(.key))
-    func `[key] duplicate keys 04`() throws {
+    @Test("[key] duplicate keys 04", .tags(.key))
+    func key__duplicate_keys_04() throws {
         try invalidate(pathComponents: ["key", "duplicate-keys-04"])
     }
 
-    @Test(.tags(.key))
-    func `[key] duplicate keys 05`() throws {
+    @Test("[key] duplicate keys 05", .tags(.key))
+    func key__duplicate_keys_05() throws {
         try invalidate(pathComponents: ["key", "duplicate-keys-05"])
     }
 
-    @Test(.tags(.key))
-    func `[key] duplicate keys 06`() throws {
+    @Test("[key] duplicate keys 06", .tags(.key))
+    func key__duplicate_keys_06() throws {
         try invalidate(pathComponents: ["key", "duplicate-keys-06"])
     }
 
-    @Test(.tags(.key))
-    func `[key] duplicate keys 07`() throws {
+    @Test("[key] duplicate keys 07", .tags(.key))
+    func key__duplicate_keys_07() throws {
         try invalidate(pathComponents: ["key", "duplicate-keys-07"])
     }
 
-    @Test(.tags(.key))
-    func `[key] duplicate keys 08`() throws {
+    @Test("[key] duplicate keys 08", .tags(.key))
+    func key__duplicate_keys_08() throws {
         try invalidate(pathComponents: ["key", "duplicate-keys-08"])
     }
 
-    @Test(.tags(.key))
-    func `[key] duplicate keys 09`() throws {
+    @Test("[key] duplicate keys 09", .tags(.key))
+    func key__duplicate_keys_09() throws {
         try invalidate(pathComponents: ["key", "duplicate-keys-09"])
     }
 
-    @Test(.tags(.key))
-    func `[key] empty`() throws {
+    @Test("[key] empty", .tags(.key))
+    func key__empty() throws {
         try invalidate(pathComponents: ["key", "empty"])
     }
 
-    @Test(.tags(.key))
-    func `[key] end in escape`() throws {
+    @Test("[key] end in escape", .tags(.key))
+    func key__end_in_escape() throws {
         try invalidate(pathComponents: ["key", "end-in-escape"])
     }
 
-    @Test(.tags(.key))
-    func `[key] escape`() throws {
+    @Test("[key] escape", .tags(.key))
+    func key__escape() throws {
         try invalidate(pathComponents: ["key", "escape"])
     }
 
-    @Test(.tags(.key))
-    func `[key] hash`() throws {
+    @Test("[key] hash", .tags(.key))
+    func key__hash() throws {
         try invalidate(pathComponents: ["key", "hash"])
     }
 
-    @Test(.tags(.key))
-    func `[key] multiline key 01`() throws {
+    @Test("[key] multiline key 01", .tags(.key))
+    func key__multiline_key_01() throws {
         try invalidate(pathComponents: ["key", "multiline-key-01"])
     }
 
-    @Test(.tags(.key))
-    func `[key] multiline key 02`() throws {
+    @Test("[key] multiline key 02", .tags(.key))
+    func key__multiline_key_02() throws {
         try invalidate(pathComponents: ["key", "multiline-key-02"])
     }
 
-    @Test(.tags(.key))
-    func `[key] multiline key 03`() throws {
+    @Test("[key] multiline key 03", .tags(.key))
+    func key__multiline_key_03() throws {
         try invalidate(pathComponents: ["key", "multiline-key-03"])
     }
 
-    @Test(.tags(.key))
-    func `[key] multiline key 04`() throws {
+    @Test("[key] multiline key 04", .tags(.key))
+    func key__multiline_key_04() throws {
         try invalidate(pathComponents: ["key", "multiline-key-04"])
     }
 
-    @Test(.tags(.key))
-    func `[key] newline 01`() throws {
+    @Test("[key] newline 01", .tags(.key))
+    func key__newline_01() throws {
         try invalidate(pathComponents: ["key", "newline-01"])
     }
 
-    @Test(.tags(.key))
-    func `[key] newline 02`() throws {
+    @Test("[key] newline 02", .tags(.key))
+    func key__newline_02() throws {
         try invalidate(pathComponents: ["key", "newline-02"])
     }
 
-    @Test(.tags(.key))
-    func `[key] newline 03`() throws {
+    @Test("[key] newline 03", .tags(.key))
+    func key__newline_03() throws {
         try invalidate(pathComponents: ["key", "newline-03"])
     }
 
-    @Test(.tags(.key))
-    func `[key] newline 04`() throws {
+    @Test("[key] newline 04", .tags(.key))
+    func key__newline_04() throws {
         try invalidate(pathComponents: ["key", "newline-04"])
     }
 
-    @Test(.tags(.key))
-    func `[key] newline 05`() throws {
+    @Test("[key] newline 05", .tags(.key))
+    func key__newline_05() throws {
         try invalidate(pathComponents: ["key", "newline-05"])
     }
 
-    @Test(.tags(.key))
-    func `[key] newline 06`() throws {
+    @Test("[key] newline 06", .tags(.key))
+    func key__newline_06() throws {
         try invalidate(pathComponents: ["key", "newline-06"])
     }
 
-    @Test(.tags(.key))
-    func `[key] no eol 01`() throws {
+    @Test("[key] no eol 01", .tags(.key))
+    func key__no_eol_01() throws {
         try invalidate(pathComponents: ["key", "no-eol-01"])
     }
 
-    @Test(.tags(.key))
-    func `[key] no eol 02`() throws {
+    @Test("[key] no eol 02", .tags(.key))
+    func key__no_eol_02() throws {
         try invalidate(pathComponents: ["key", "no-eol-02"])
     }
 
-    @Test(.tags(.key))
-    func `[key] no eol 03`() throws {
+    @Test("[key] no eol 03", .tags(.key))
+    func key__no_eol_03() throws {
         try invalidate(pathComponents: ["key", "no-eol-03"])
     }
 
-    @Test(.tags(.key))
-    func `[key] no eol 04`() throws {
+    @Test("[key] no eol 04", .tags(.key))
+    func key__no_eol_04() throws {
         try invalidate(pathComponents: ["key", "no-eol-04"])
     }
 
-    @Test(.tags(.key))
-    func `[key] no eol 05`() throws {
+    @Test("[key] no eol 05", .tags(.key))
+    func key__no_eol_05() throws {
         try invalidate(pathComponents: ["key", "no-eol-05"])
     }
 
-    @Test(.tags(.key))
-    func `[key] no eol 06`() throws {
+    @Test("[key] no eol 06", .tags(.key))
+    func key__no_eol_06() throws {
         try invalidate(pathComponents: ["key", "no-eol-06"])
     }
 
-    @Test(.tags(.key))
-    func `[key] no eol 07`() throws {
+    @Test("[key] no eol 07", .tags(.key))
+    func key__no_eol_07() throws {
         try invalidate(pathComponents: ["key", "no-eol-07"])
     }
 
-    @Test(.tags(.key))
-    func `[key] only float`() throws {
+    @Test("[key] only float", .tags(.key))
+    func key__only_float() throws {
         try invalidate(pathComponents: ["key", "only-float"])
     }
 
-    @Test(.tags(.key))
-    func `[key] only int`() throws {
+    @Test("[key] only int", .tags(.key))
+    func key__only_int() throws {
         try invalidate(pathComponents: ["key", "only-int"])
     }
 
-    @Test(.tags(.key))
-    func `[key] only str`() throws {
+    @Test("[key] only str", .tags(.key))
+    func key__only_str() throws {
         try invalidate(pathComponents: ["key", "only-str"])
     }
 
-    @Test(.tags(.key))
-    func `[key] open bracket`() throws {
+    @Test("[key] open bracket", .tags(.key))
+    func key__open_bracket() throws {
         try invalidate(pathComponents: ["key", "open-bracket"])
     }
 
-    @Test(.tags(.key))
-    func `[key] partial quoted`() throws {
+    @Test("[key] partial quoted", .tags(.key))
+    func key__partial_quoted() throws {
         try invalidate(pathComponents: ["key", "partial-quoted"])
     }
 
-    @Test(.tags(.key))
-    func `[key] quoted unclosed 01`() throws {
+    @Test("[key] quoted unclosed 01", .tags(.key))
+    func key__quoted_unclosed_01() throws {
         try invalidate(pathComponents: ["key", "quoted-unclosed-01"])
     }
 
-    @Test(.tags(.key))
-    func `[key] quoted unclosed 02`() throws {
+    @Test("[key] quoted unclosed 02", .tags(.key))
+    func key__quoted_unclosed_02() throws {
         try invalidate(pathComponents: ["key", "quoted-unclosed-02"])
     }
 
-    @Test(.tags(.key))
-    func `[key] single open bracket`() throws {
+    @Test("[key] single open bracket", .tags(.key))
+    func key__single_open_bracket() throws {
         try invalidate(pathComponents: ["key", "single-open-bracket"])
     }
 
-    @Test(.tags(.key))
-    func `[key] space`() throws {
+    @Test("[key] space", .tags(.key))
+    func key__space() throws {
         try invalidate(pathComponents: ["key", "space"])
     }
 
-    @Test(.tags(.key))
-    func `[key] special character`() throws {
+    @Test("[key] special character", .tags(.key))
+    func key__special_character() throws {
         try invalidate(pathComponents: ["key", "special-character"])
     }
 
-    @Test(.tags(.key))
-    func `[key] start bracket`() throws {
+    @Test("[key] start bracket", .tags(.key))
+    func key__start_bracket() throws {
         try invalidate(pathComponents: ["key", "start-bracket"])
     }
 
-    @Test(.tags(.key))
-    func `[key] start dot`() throws {
+    @Test("[key] start dot", .tags(.key))
+    func key__start_dot() throws {
         try invalidate(pathComponents: ["key", "start-dot"])
     }
 
-    @Test(.tags(.key))
-    func `[key] two equals 01`() throws {
+    @Test("[key] two equals 01", .tags(.key))
+    func key__two_equals_01() throws {
         try invalidate(pathComponents: ["key", "two-equals-01"])
     }
 
-    @Test(.tags(.key))
-    func `[key] two equals 02`() throws {
+    @Test("[key] two equals 02", .tags(.key))
+    func key__two_equals_02() throws {
         try invalidate(pathComponents: ["key", "two-equals-02"])
     }
 
-    @Test(.tags(.key))
-    func `[key] two equals 03`() throws {
+    @Test("[key] two equals 03", .tags(.key))
+    func key__two_equals_03() throws {
         try invalidate(pathComponents: ["key", "two-equals-03"])
     }
 
-    @Test(.tags(.key))
-    func `[key] without value 01`() throws {
+    @Test("[key] without value 01", .tags(.key))
+    func key__without_value_01() throws {
         try invalidate(pathComponents: ["key", "without-value-01"])
     }
 
-    @Test(.tags(.key))
-    func `[key] without value 02`() throws {
+    @Test("[key] without value 02", .tags(.key))
+    func key__without_value_02() throws {
         try invalidate(pathComponents: ["key", "without-value-02"])
     }
 
-    @Test(.tags(.key))
-    func `[key] without value 03`() throws {
+    @Test("[key] without value 03", .tags(.key))
+    func key__without_value_03() throws {
         try invalidate(pathComponents: ["key", "without-value-03"])
     }
 
-    @Test(.tags(.key))
-    func `[key] without value 04`() throws {
+    @Test("[key] without value 04", .tags(.key))
+    func key__without_value_04() throws {
         try invalidate(pathComponents: ["key", "without-value-04"])
     }
 
-    @Test(.tags(.key))
-    func `[key] without value 05`() throws {
+    @Test("[key] without value 05", .tags(.key))
+    func key__without_value_05() throws {
         try invalidate(pathComponents: ["key", "without-value-05"])
     }
 
-    @Test(.tags(.key))
-    func `[key] without value 06`() throws {
+    @Test("[key] without value 06", .tags(.key))
+    func key__without_value_06() throws {
         try invalidate(pathComponents: ["key", "without-value-06"])
     }
 
-    @Test(.tags(.key))
-    func `[key] without value 07`() throws {
+    @Test("[key] without value 07", .tags(.key))
+    func key__without_value_07() throws {
         try invalidate(pathComponents: ["key", "without-value-07"])
     }
 
-    @Test(.tags(.local_date))
-    func `[local-date] day 1digit`() throws {
+    @Test("[local-date] day 1digit", .tags(.local_date))
+    func local_date__day_1digit() throws {
         try invalidate(pathComponents: ["local-date", "day-1digit"])
     }
 
-    @Test(.tags(.local_date))
-    func `[local-date] feb 29`() throws {
+    @Test("[local-date] feb 29", .tags(.local_date))
+    func local_date__feb_29() throws {
         try invalidate(pathComponents: ["local-date", "feb-29"])
     }
 
-    @Test(.tags(.local_date))
-    func `[local-date] feb 30`() throws {
+    @Test("[local-date] feb 30", .tags(.local_date))
+    func local_date__feb_30() throws {
         try invalidate(pathComponents: ["local-date", "feb-30"])
     }
 
-    @Test(.tags(.local_date))
-    func `[local-date] mday over`() throws {
+    @Test("[local-date] mday over", .tags(.local_date))
+    func local_date__mday_over() throws {
         try invalidate(pathComponents: ["local-date", "mday-over"])
     }
 
-    @Test(.tags(.local_date))
-    func `[local-date] mday under`() throws {
+    @Test("[local-date] mday under", .tags(.local_date))
+    func local_date__mday_under() throws {
         try invalidate(pathComponents: ["local-date", "mday-under"])
     }
 
-    @Test(.tags(.local_date))
-    func `[local-date] month over`() throws {
+    @Test("[local-date] month over", .tags(.local_date))
+    func local_date__month_over() throws {
         try invalidate(pathComponents: ["local-date", "month-over"])
     }
 
-    @Test(.tags(.local_date))
-    func `[local-date] month under`() throws {
+    @Test("[local-date] month under", .tags(.local_date))
+    func local_date__month_under() throws {
         try invalidate(pathComponents: ["local-date", "month-under"])
     }
 
-    @Test(.tags(.local_date))
-    func `[local-date] no leads`() throws {
+    @Test("[local-date] no leads", .tags(.local_date))
+    func local_date__no_leads() throws {
         try invalidate(pathComponents: ["local-date", "no-leads"])
     }
 
-    @Test(.tags(.local_date))
-    func `[local-date] no leads with milli`() throws {
+    @Test("[local-date] no leads with milli", .tags(.local_date))
+    func local_date__no_leads_with_milli() throws {
         try invalidate(pathComponents: ["local-date", "no-leads-with-milli"])
     }
 
-    @Test(.tags(.local_date))
-    func `[local-date] trailing t`() throws {
+    @Test("[local-date] trailing t", .tags(.local_date))
+    func local_date__trailing_t() throws {
         try invalidate(pathComponents: ["local-date", "trailing-t"])
     }
 
-    @Test(.tags(.local_date))
-    func `[local-date] y10k`() throws {
+    @Test("[local-date] y10k", .tags(.local_date))
+    func local_date__y10k() throws {
         try invalidate(pathComponents: ["local-date", "y10k"])
     }
 
-    @Test(.tags(.local_date))
-    func `[local-date] year 3digits`() throws {
+    @Test("[local-date] year 3digits", .tags(.local_date))
+    func local_date__year_3digits() throws {
         try invalidate(pathComponents: ["local-date", "year-3digits"])
     }
 
-    @Test(.tags(.local_datetime))
-    func `[local-datetime] feb 29`() throws {
+    @Test("[local-datetime] feb 29", .tags(.local_datetime))
+    func local_datetime__feb_29() throws {
         try invalidate(pathComponents: ["local-datetime", "feb-29"])
     }
 
-    @Test(.tags(.local_datetime))
-    func `[local-datetime] feb 30`() throws {
+    @Test("[local-datetime] feb 30", .tags(.local_datetime))
+    func local_datetime__feb_30() throws {
         try invalidate(pathComponents: ["local-datetime", "feb-30"])
     }
 
-    @Test(.tags(.local_datetime))
-    func `[local-datetime] hour over`() throws {
+    @Test("[local-datetime] hour over", .tags(.local_datetime))
+    func local_datetime__hour_over() throws {
         try invalidate(pathComponents: ["local-datetime", "hour-over"])
     }
 
-    @Test(.tags(.local_datetime))
-    func `[local-datetime] mday over`() throws {
+    @Test("[local-datetime] mday over", .tags(.local_datetime))
+    func local_datetime__mday_over() throws {
         try invalidate(pathComponents: ["local-datetime", "mday-over"])
     }
 
-    @Test(.tags(.local_datetime))
-    func `[local-datetime] mday under`() throws {
+    @Test("[local-datetime] mday under", .tags(.local_datetime))
+    func local_datetime__mday_under() throws {
         try invalidate(pathComponents: ["local-datetime", "mday-under"])
     }
 
-    @Test(.tags(.local_datetime))
-    func `[local-datetime] minute over`() throws {
+    @Test("[local-datetime] minute over", .tags(.local_datetime))
+    func local_datetime__minute_over() throws {
         try invalidate(pathComponents: ["local-datetime", "minute-over"])
     }
 
-    @Test(.tags(.local_datetime))
-    func `[local-datetime] month over`() throws {
+    @Test("[local-datetime] month over", .tags(.local_datetime))
+    func local_datetime__month_over() throws {
         try invalidate(pathComponents: ["local-datetime", "month-over"])
     }
 
-    @Test(.tags(.local_datetime))
-    func `[local-datetime] month under`() throws {
+    @Test("[local-datetime] month under", .tags(.local_datetime))
+    func local_datetime__month_under() throws {
         try invalidate(pathComponents: ["local-datetime", "month-under"])
     }
 
-    @Test(.tags(.local_datetime))
-    func `[local-datetime] no leads`() throws {
+    @Test("[local-datetime] no leads", .tags(.local_datetime))
+    func local_datetime__no_leads() throws {
         try invalidate(pathComponents: ["local-datetime", "no-leads"])
     }
 
-    @Test(.tags(.local_datetime))
-    func `[local-datetime] no leads with milli`() throws {
+    @Test("[local-datetime] no leads with milli", .tags(.local_datetime))
+    func local_datetime__no_leads_with_milli() throws {
         try invalidate(pathComponents: ["local-datetime", "no-leads-with-milli"])
     }
 
-    @Test(.tags(.local_datetime))
-    func `[local-datetime] no t`() throws {
+    @Test("[local-datetime] no t", .tags(.local_datetime))
+    func local_datetime__no_t() throws {
         try invalidate(pathComponents: ["local-datetime", "no-t"])
     }
 
-    @Test(.tags(.local_datetime))
-    func `[local-datetime] second over`() throws {
+    @Test("[local-datetime] second over", .tags(.local_datetime))
+    func local_datetime__second_over() throws {
         try invalidate(pathComponents: ["local-datetime", "second-over"])
     }
 
-    @Test(.tags(.local_datetime))
-    func `[local-datetime] time no leads`() throws {
+    @Test("[local-datetime] time no leads", .tags(.local_datetime))
+    func local_datetime__time_no_leads() throws {
         try invalidate(pathComponents: ["local-datetime", "time-no-leads"])
     }
 
-    @Test(.tags(.local_datetime))
-    func `[local-datetime] y10k`() throws {
+    @Test("[local-datetime] y10k", .tags(.local_datetime))
+    func local_datetime__y10k() throws {
         try invalidate(pathComponents: ["local-datetime", "y10k"])
     }
 
-    @Test(.tags(.local_time))
-    func `[local-time] hour over`() throws {
+    @Test("[local-time] hour over", .tags(.local_time))
+    func local_time__hour_over() throws {
         try invalidate(pathComponents: ["local-time", "hour-over"])
     }
 
-    @Test(.tags(.local_time))
-    func `[local-time] minute over`() throws {
+    @Test("[local-time] minute over", .tags(.local_time))
+    func local_time__minute_over() throws {
         try invalidate(pathComponents: ["local-time", "minute-over"])
     }
 
-    @Test(.tags(.local_time))
-    func `[local-time] second over`() throws {
+    @Test("[local-time] second over", .tags(.local_time))
+    func local_time__second_over() throws {
         try invalidate(pathComponents: ["local-time", "second-over"])
     }
 
-    @Test(.tags(.local_time))
-    func `[local-time] time no leads 01`() throws {
+    @Test("[local-time] time no leads 01", .tags(.local_time))
+    func local_time__time_no_leads_01() throws {
         try invalidate(pathComponents: ["local-time", "time-no-leads-01"])
     }
 
-    @Test(.tags(.local_time))
-    func `[local-time] time no leads 02`() throws {
+    @Test("[local-time] time no leads 02", .tags(.local_time))
+    func local_time__time_no_leads_02() throws {
         try invalidate(pathComponents: ["local-time", "time-no-leads-02"])
     }
 
-    @Test(.tags(.local_time))
-    func `[local-time] trailing dot`() throws {
+    @Test("[local-time] trailing dot", .tags(.local_time))
+    func local_time__trailing_dot() throws {
         try invalidate(pathComponents: ["local-time", "trailing-dot"])
     }
 
-    @Test(.tags(.local_time))
-    func `[local-time] trailing dotdot`() throws {
+    @Test("[local-time] trailing dotdot", .tags(.local_time))
+    func local_time__trailing_dotdot() throws {
         try invalidate(pathComponents: ["local-time", "trailing-dotdot"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 16 0`() throws {
+    @Test("[spec-1.1.0] common 16 0", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_16_0() throws {
         try invalidate(pathComponents: ["spec-1.1.0", "common-16-0"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 19 0`() throws {
+    @Test("[spec-1.1.0] common 19 0", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_19_0() throws {
         try invalidate(pathComponents: ["spec-1.1.0", "common-19-0"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 2`() throws {
+    @Test("[spec-1.1.0] common 2", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_2() throws {
         try invalidate(pathComponents: ["spec-1.1.0", "common-2"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 46 0`() throws {
+    @Test("[spec-1.1.0] common 46 0", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_46_0() throws {
         try invalidate(pathComponents: ["spec-1.1.0", "common-46-0"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 46 1`() throws {
+    @Test("[spec-1.1.0] common 46 1", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_46_1() throws {
         try invalidate(pathComponents: ["spec-1.1.0", "common-46-1"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 49 0`() throws {
+    @Test("[spec-1.1.0] common 49 0", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_49_0() throws {
         try invalidate(pathComponents: ["spec-1.1.0", "common-49-0"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 5`() throws {
+    @Test("[spec-1.1.0] common 5", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_5() throws {
         try invalidate(pathComponents: ["spec-1.1.0", "common-5"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 50 0`() throws {
+    @Test("[spec-1.1.0] common 50 0", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_50_0() throws {
         try invalidate(pathComponents: ["spec-1.1.0", "common-50-0"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad byte escape`() throws {
+    @Test("[string] bad byte escape", .tags(.string))
+    func string__bad_byte_escape() throws {
         try invalidate(pathComponents: ["string", "bad-byte-escape"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad concat`() throws {
+    @Test("[string] bad concat", .tags(.string))
+    func string__bad_concat() throws {
         try invalidate(pathComponents: ["string", "bad-concat"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad escape 01`() throws {
+    @Test("[string] bad escape 01", .tags(.string))
+    func string__bad_escape_01() throws {
         try invalidate(pathComponents: ["string", "bad-escape-01"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad escape 02`() throws {
+    @Test("[string] bad escape 02", .tags(.string))
+    func string__bad_escape_02() throws {
         try invalidate(pathComponents: ["string", "bad-escape-02"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad escape 03`() throws {
+    @Test("[string] bad escape 03", .tags(.string))
+    func string__bad_escape_03() throws {
         try invalidate(pathComponents: ["string", "bad-escape-03"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad escape 04`() throws {
+    @Test("[string] bad escape 04", .tags(.string))
+    func string__bad_escape_04() throws {
         try invalidate(pathComponents: ["string", "bad-escape-04"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad escape 05`() throws {
+    @Test("[string] bad escape 05", .tags(.string))
+    func string__bad_escape_05() throws {
         try invalidate(pathComponents: ["string", "bad-escape-05"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad hex esc 01`() throws {
+    @Test("[string] bad hex esc 01", .tags(.string))
+    func string__bad_hex_esc_01() throws {
         try invalidate(pathComponents: ["string", "bad-hex-esc-01"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad hex esc 02`() throws {
+    @Test("[string] bad hex esc 02", .tags(.string))
+    func string__bad_hex_esc_02() throws {
         try invalidate(pathComponents: ["string", "bad-hex-esc-02"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad hex esc 03`() throws {
+    @Test("[string] bad hex esc 03", .tags(.string))
+    func string__bad_hex_esc_03() throws {
         try invalidate(pathComponents: ["string", "bad-hex-esc-03"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad hex esc 04`() throws {
+    @Test("[string] bad hex esc 04", .tags(.string))
+    func string__bad_hex_esc_04() throws {
         try invalidate(pathComponents: ["string", "bad-hex-esc-04"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad hex esc 05`() throws {
+    @Test("[string] bad hex esc 05", .tags(.string))
+    func string__bad_hex_esc_05() throws {
         try invalidate(pathComponents: ["string", "bad-hex-esc-05"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad multiline`() throws {
+    @Test("[string] bad multiline", .tags(.string))
+    func string__bad_multiline() throws {
         try invalidate(pathComponents: ["string", "bad-multiline"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad slash escape`() throws {
+    @Test("[string] bad slash escape", .tags(.string))
+    func string__bad_slash_escape() throws {
         try invalidate(pathComponents: ["string", "bad-slash-escape"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad uni esc 01`() throws {
+    @Test("[string] bad uni esc 01", .tags(.string))
+    func string__bad_uni_esc_01() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-01"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad uni esc 02`() throws {
+    @Test("[string] bad uni esc 02", .tags(.string))
+    func string__bad_uni_esc_02() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-02"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad uni esc 03`() throws {
+    @Test("[string] bad uni esc 03", .tags(.string))
+    func string__bad_uni_esc_03() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-03"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad uni esc 04`() throws {
+    @Test("[string] bad uni esc 04", .tags(.string))
+    func string__bad_uni_esc_04() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-04"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad uni esc 05`() throws {
+    @Test("[string] bad uni esc 05", .tags(.string))
+    func string__bad_uni_esc_05() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-05"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad uni esc 06`() throws {
+    @Test("[string] bad uni esc 06", .tags(.string))
+    func string__bad_uni_esc_06() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-06"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad uni esc 07`() throws {
+    @Test("[string] bad uni esc 07", .tags(.string))
+    func string__bad_uni_esc_07() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-07"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad uni esc ml 01`() throws {
+    @Test("[string] bad uni esc ml 01", .tags(.string))
+    func string__bad_uni_esc_ml_01() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-ml-01"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad uni esc ml 02`() throws {
+    @Test("[string] bad uni esc ml 02", .tags(.string))
+    func string__bad_uni_esc_ml_02() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-ml-02"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad uni esc ml 03`() throws {
+    @Test("[string] bad uni esc ml 03", .tags(.string))
+    func string__bad_uni_esc_ml_03() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-ml-03"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad uni esc ml 04`() throws {
+    @Test("[string] bad uni esc ml 04", .tags(.string))
+    func string__bad_uni_esc_ml_04() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-ml-04"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad uni esc ml 05`() throws {
+    @Test("[string] bad uni esc ml 05", .tags(.string))
+    func string__bad_uni_esc_ml_05() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-ml-05"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad uni esc ml 06`() throws {
+    @Test("[string] bad uni esc ml 06", .tags(.string))
+    func string__bad_uni_esc_ml_06() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-ml-06"])
     }
 
-    @Test(.tags(.string))
-    func `[string] bad uni esc ml 07`() throws {
+    @Test("[string] bad uni esc ml 07", .tags(.string))
+    func string__bad_uni_esc_ml_07() throws {
         try invalidate(pathComponents: ["string", "bad-uni-esc-ml-07"])
     }
 
-    @Test(.tags(.string))
-    func `[string] basic multiline out of range unicode escape 01`() throws {
+    @Test("[string] basic multiline out of range unicode escape 01", .tags(.string))
+    func string__basic_multiline_out_of_range_unicode_escape_01() throws {
         try invalidate(pathComponents: ["string", "basic-multiline-out-of-range-unicode-escape-01"])
     }
 
-    @Test(.tags(.string))
-    func `[string] basic multiline out of range unicode escape 02`() throws {
+    @Test("[string] basic multiline out of range unicode escape 02", .tags(.string))
+    func string__basic_multiline_out_of_range_unicode_escape_02() throws {
         try invalidate(pathComponents: ["string", "basic-multiline-out-of-range-unicode-escape-02"])
     }
 
-    @Test(.tags(.string))
-    func `[string] basic multiline quotes`() throws {
+    @Test("[string] basic multiline quotes", .tags(.string))
+    func string__basic_multiline_quotes() throws {
         try invalidate(pathComponents: ["string", "basic-multiline-quotes"])
     }
 
-    @Test(.tags(.string))
-    func `[string] basic multiline unknown escape`() throws {
+    @Test("[string] basic multiline unknown escape", .tags(.string))
+    func string__basic_multiline_unknown_escape() throws {
         try invalidate(pathComponents: ["string", "basic-multiline-unknown-escape"])
     }
 
-    @Test(.tags(.string))
-    func `[string] basic out of range unicode escape 01`() throws {
+    @Test("[string] basic out of range unicode escape 01", .tags(.string))
+    func string__basic_out_of_range_unicode_escape_01() throws {
         try invalidate(pathComponents: ["string", "basic-out-of-range-unicode-escape-01"])
     }
 
-    @Test(.tags(.string))
-    func `[string] basic out of range unicode escape 02`() throws {
+    @Test("[string] basic out of range unicode escape 02", .tags(.string))
+    func string__basic_out_of_range_unicode_escape_02() throws {
         try invalidate(pathComponents: ["string", "basic-out-of-range-unicode-escape-02"])
     }
 
-    @Test(.tags(.string))
-    func `[string] basic unknown escape`() throws {
+    @Test("[string] basic unknown escape", .tags(.string))
+    func string__basic_unknown_escape() throws {
         try invalidate(pathComponents: ["string", "basic-unknown-escape"])
     }
 
-    @Test(.tags(.string))
-    func `[string] literal multiline quotes 01`() throws {
+    @Test("[string] literal multiline quotes 01", .tags(.string))
+    func string__literal_multiline_quotes_01() throws {
         try invalidate(pathComponents: ["string", "literal-multiline-quotes-01"])
     }
 
-    @Test(.tags(.string))
-    func `[string] literal multiline quotes 02`() throws {
+    @Test("[string] literal multiline quotes 02", .tags(.string))
+    func string__literal_multiline_quotes_02() throws {
         try invalidate(pathComponents: ["string", "literal-multiline-quotes-02"])
     }
 
-    @Test(.tags(.string))
-    func `[string] missing quotes`() throws {
+    @Test("[string] missing quotes", .tags(.string))
+    func string__missing_quotes() throws {
         try invalidate(pathComponents: ["string", "missing-quotes"])
     }
 
-    @Test(.tags(.string))
-    func `[string] missing quotes array`() throws {
+    @Test("[string] missing quotes array", .tags(.string))
+    func string__missing_quotes_array() throws {
         try invalidate(pathComponents: ["string", "missing-quotes-array"])
     }
 
-    @Test(.tags(.string))
-    func `[string] missing quotes inline table`() throws {
+    @Test("[string] missing quotes inline table", .tags(.string))
+    func string__missing_quotes_inline_table() throws {
         try invalidate(pathComponents: ["string", "missing-quotes-inline-table"])
     }
 
-    @Test(.tags(.string))
-    func `[string] multiline bad escape 01`() throws {
+    @Test("[string] multiline bad escape 01", .tags(.string))
+    func string__multiline_bad_escape_01() throws {
         try invalidate(pathComponents: ["string", "multiline-bad-escape-01"])
     }
 
-    @Test(.tags(.string))
-    func `[string] multiline bad escape 02`() throws {
+    @Test("[string] multiline bad escape 02", .tags(.string))
+    func string__multiline_bad_escape_02() throws {
         try invalidate(pathComponents: ["string", "multiline-bad-escape-02"])
     }
 
-    @Test(.tags(.string))
-    func `[string] multiline bad escape 03`() throws {
+    @Test("[string] multiline bad escape 03", .tags(.string))
+    func string__multiline_bad_escape_03() throws {
         try invalidate(pathComponents: ["string", "multiline-bad-escape-03"])
     }
 
-    @Test(.tags(.string))
-    func `[string] multiline bad escape 04`() throws {
+    @Test("[string] multiline bad escape 04", .tags(.string))
+    func string__multiline_bad_escape_04() throws {
         try invalidate(pathComponents: ["string", "multiline-bad-escape-04"])
     }
 
-    @Test(.tags(.string))
-    func `[string] multiline escape space 01`() throws {
+    @Test("[string] multiline escape space 01", .tags(.string))
+    func string__multiline_escape_space_01() throws {
         try invalidate(pathComponents: ["string", "multiline-escape-space-01"])
     }
 
-    @Test(.tags(.string))
-    func `[string] multiline escape space 02`() throws {
+    @Test("[string] multiline escape space 02", .tags(.string))
+    func string__multiline_escape_space_02() throws {
         try invalidate(pathComponents: ["string", "multiline-escape-space-02"])
     }
 
-    @Test(.tags(.string))
-    func `[string] multiline lit no close 01`() throws {
+    @Test("[string] multiline lit no close 01", .tags(.string))
+    func string__multiline_lit_no_close_01() throws {
         try invalidate(pathComponents: ["string", "multiline-lit-no-close-01"])
     }
 
-    @Test(.tags(.string))
-    func `[string] multiline lit no close 02`() throws {
+    @Test("[string] multiline lit no close 02", .tags(.string))
+    func string__multiline_lit_no_close_02() throws {
         try invalidate(pathComponents: ["string", "multiline-lit-no-close-02"])
     }
 
-    @Test(.tags(.string))
-    func `[string] multiline lit no close 03`() throws {
+    @Test("[string] multiline lit no close 03", .tags(.string))
+    func string__multiline_lit_no_close_03() throws {
         try invalidate(pathComponents: ["string", "multiline-lit-no-close-03"])
     }
 
-    @Test(.tags(.string))
-    func `[string] multiline lit no close 04`() throws {
+    @Test("[string] multiline lit no close 04", .tags(.string))
+    func string__multiline_lit_no_close_04() throws {
         try invalidate(pathComponents: ["string", "multiline-lit-no-close-04"])
     }
 
-    @Test(.tags(.string))
-    func `[string] multiline no close 01`() throws {
+    @Test("[string] multiline no close 01", .tags(.string))
+    func string__multiline_no_close_01() throws {
         try invalidate(pathComponents: ["string", "multiline-no-close-01"])
     }
 
-    @Test(.tags(.string))
-    func `[string] multiline no close 02`() throws {
+    @Test("[string] multiline no close 02", .tags(.string))
+    func string__multiline_no_close_02() throws {
         try invalidate(pathComponents: ["string", "multiline-no-close-02"])
     }
 
-    @Test(.tags(.string))
-    func `[string] multiline no close 03`() throws {
+    @Test("[string] multiline no close 03", .tags(.string))
+    func string__multiline_no_close_03() throws {
         try invalidate(pathComponents: ["string", "multiline-no-close-03"])
     }
 
-    @Test(.tags(.string))
-    func `[string] multiline no close 04`() throws {
+    @Test("[string] multiline no close 04", .tags(.string))
+    func string__multiline_no_close_04() throws {
         try invalidate(pathComponents: ["string", "multiline-no-close-04"])
     }
 
-    @Test(.tags(.string))
-    func `[string] multiline no close 05`() throws {
+    @Test("[string] multiline no close 05", .tags(.string))
+    func string__multiline_no_close_05() throws {
         try invalidate(pathComponents: ["string", "multiline-no-close-05"])
     }
 
-    @Test(.tags(.string))
-    func `[string] multiline quotes 01`() throws {
+    @Test("[string] multiline quotes 01", .tags(.string))
+    func string__multiline_quotes_01() throws {
         try invalidate(pathComponents: ["string", "multiline-quotes-01"])
     }
 
-    @Test(.tags(.string))
-    func `[string] no close 01`() throws {
+    @Test("[string] no close 01", .tags(.string))
+    func string__no_close_01() throws {
         try invalidate(pathComponents: ["string", "no-close-01"])
     }
 
-    @Test(.tags(.string))
-    func `[string] no close 02`() throws {
+    @Test("[string] no close 02", .tags(.string))
+    func string__no_close_02() throws {
         try invalidate(pathComponents: ["string", "no-close-02"])
     }
 
-    @Test(.tags(.string))
-    func `[string] no close 03`() throws {
+    @Test("[string] no close 03", .tags(.string))
+    func string__no_close_03() throws {
         try invalidate(pathComponents: ["string", "no-close-03"])
     }
 
-    @Test(.tags(.string))
-    func `[string] no close 04`() throws {
+    @Test("[string] no close 04", .tags(.string))
+    func string__no_close_04() throws {
         try invalidate(pathComponents: ["string", "no-close-04"])
     }
 
-    @Test(.tags(.string))
-    func `[string] no close 05`() throws {
+    @Test("[string] no close 05", .tags(.string))
+    func string__no_close_05() throws {
         try invalidate(pathComponents: ["string", "no-close-05"])
     }
 
-    @Test(.tags(.string))
-    func `[string] no close 06`() throws {
+    @Test("[string] no close 06", .tags(.string))
+    func string__no_close_06() throws {
         try invalidate(pathComponents: ["string", "no-close-06"])
     }
 
-    @Test(.tags(.string))
-    func `[string] no close 07`() throws {
+    @Test("[string] no close 07", .tags(.string))
+    func string__no_close_07() throws {
         try invalidate(pathComponents: ["string", "no-close-07"])
     }
 
-    @Test(.tags(.string))
-    func `[string] no close 08`() throws {
+    @Test("[string] no close 08", .tags(.string))
+    func string__no_close_08() throws {
         try invalidate(pathComponents: ["string", "no-close-08"])
     }
 
-    @Test(.tags(.string))
-    func `[string] no close 09`() throws {
+    @Test("[string] no close 09", .tags(.string))
+    func string__no_close_09() throws {
         try invalidate(pathComponents: ["string", "no-close-09"])
     }
 
-    @Test(.tags(.string))
-    func `[string] no close 10`() throws {
+    @Test("[string] no close 10", .tags(.string))
+    func string__no_close_10() throws {
         try invalidate(pathComponents: ["string", "no-close-10"])
     }
 
-    @Test(.tags(.string))
-    func `[string] no open 01`() throws {
+    @Test("[string] no open 01", .tags(.string))
+    func string__no_open_01() throws {
         try invalidate(pathComponents: ["string", "no-open-01"])
     }
 
-    @Test(.tags(.string))
-    func `[string] no open 02`() throws {
+    @Test("[string] no open 02", .tags(.string))
+    func string__no_open_02() throws {
         try invalidate(pathComponents: ["string", "no-open-02"])
     }
 
-    @Test(.tags(.string))
-    func `[string] no open 03`() throws {
+    @Test("[string] no open 03", .tags(.string))
+    func string__no_open_03() throws {
         try invalidate(pathComponents: ["string", "no-open-03"])
     }
 
-    @Test(.tags(.string))
-    func `[string] no open 04`() throws {
+    @Test("[string] no open 04", .tags(.string))
+    func string__no_open_04() throws {
         try invalidate(pathComponents: ["string", "no-open-04"])
     }
 
-    @Test(.tags(.string))
-    func `[string] no open 05`() throws {
+    @Test("[string] no open 05", .tags(.string))
+    func string__no_open_05() throws {
         try invalidate(pathComponents: ["string", "no-open-05"])
     }
 
-    @Test(.tags(.string))
-    func `[string] no open 06`() throws {
+    @Test("[string] no open 06", .tags(.string))
+    func string__no_open_06() throws {
         try invalidate(pathComponents: ["string", "no-open-06"])
     }
 
-    @Test(.tags(.string))
-    func `[string] no open 07`() throws {
+    @Test("[string] no open 07", .tags(.string))
+    func string__no_open_07() throws {
         try invalidate(pathComponents: ["string", "no-open-07"])
     }
 
-    @Test(.tags(.string))
-    func `[string] no open 08`() throws {
+    @Test("[string] no open 08", .tags(.string))
+    func string__no_open_08() throws {
         try invalidate(pathComponents: ["string", "no-open-08"])
     }
 
-    @Test(.tags(.string))
-    func `[string] text after string`() throws {
+    @Test("[string] text after string", .tags(.string))
+    func string__text_after_string() throws {
         try invalidate(pathComponents: ["string", "text-after-string"])
     }
 
-    @Test(.tags(.string))
-    func `[string] wrong close`() throws {
+    @Test("[string] wrong close", .tags(.string))
+    func string__wrong_close() throws {
         try invalidate(pathComponents: ["string", "wrong-close"])
     }
 
-    @Test(.tags(.table))
-    func `[table] append with dotted keys 01`() throws {
+    @Test("[table] append with dotted keys 01", .tags(.table))
+    func table__append_with_dotted_keys_01() throws {
         try invalidate(pathComponents: ["table", "append-with-dotted-keys-01"])
     }
 
-    @Test(.tags(.table))
-    func `[table] append with dotted keys 02`() throws {
+    @Test("[table] append with dotted keys 02", .tags(.table))
+    func table__append_with_dotted_keys_02() throws {
         try invalidate(pathComponents: ["table", "append-with-dotted-keys-02"])
     }
 
-    @Test(.tags(.table))
-    func `[table] append with dotted keys 03`() throws {
+    @Test("[table] append with dotted keys 03", .tags(.table))
+    func table__append_with_dotted_keys_03() throws {
         try invalidate(pathComponents: ["table", "append-with-dotted-keys-03"])
     }
 
-    @Test(.tags(.table))
-    func `[table] append with dotted keys 04`() throws {
+    @Test("[table] append with dotted keys 04", .tags(.table))
+    func table__append_with_dotted_keys_04() throws {
         try invalidate(pathComponents: ["table", "append-with-dotted-keys-04"])
     }
 
-    @Test(.tags(.table))
-    func `[table] append with dotted keys 05`() throws {
+    @Test("[table] append with dotted keys 05", .tags(.table))
+    func table__append_with_dotted_keys_05() throws {
         try invalidate(pathComponents: ["table", "append-with-dotted-keys-05"])
     }
 
-    @Test(.tags(.table))
-    func `[table] append with dotted keys 06`() throws {
+    @Test("[table] append with dotted keys 06", .tags(.table))
+    func table__append_with_dotted_keys_06() throws {
         try invalidate(pathComponents: ["table", "append-with-dotted-keys-06"])
     }
 
-    @Test(.tags(.table))
-    func `[table] append with dotted keys 07`() throws {
+    @Test("[table] append with dotted keys 07", .tags(.table))
+    func table__append_with_dotted_keys_07() throws {
         try invalidate(pathComponents: ["table", "append-with-dotted-keys-07"])
     }
 
-    @Test(.tags(.table))
-    func `[table] array empty`() throws {
+    @Test("[table] array empty", .tags(.table))
+    func table__array_empty() throws {
         try invalidate(pathComponents: ["table", "array-empty"])
     }
 
-    @Test(.tags(.table))
-    func `[table] array implicit`() throws {
+    @Test("[table] array implicit", .tags(.table))
+    func table__array_implicit() throws {
         try invalidate(pathComponents: ["table", "array-implicit"])
     }
 
-    @Test(.tags(.table))
-    func `[table] array no close 01`() throws {
+    @Test("[table] array no close 01", .tags(.table))
+    func table__array_no_close_01() throws {
         try invalidate(pathComponents: ["table", "array-no-close-01"])
     }
 
-    @Test(.tags(.table))
-    func `[table] array no close 02`() throws {
+    @Test("[table] array no close 02", .tags(.table))
+    func table__array_no_close_02() throws {
         try invalidate(pathComponents: ["table", "array-no-close-02"])
     }
 
-    @Test(.tags(.table))
-    func `[table] array no close 03`() throws {
+    @Test("[table] array no close 03", .tags(.table))
+    func table__array_no_close_03() throws {
         try invalidate(pathComponents: ["table", "array-no-close-03"])
     }
 
-    @Test(.tags(.table))
-    func `[table] array no close 04`() throws {
+    @Test("[table] array no close 04", .tags(.table))
+    func table__array_no_close_04() throws {
         try invalidate(pathComponents: ["table", "array-no-close-04"])
     }
 
-    @Test(.tags(.table))
-    func `[table] bare invalid character 01`() throws {
+    @Test("[table] bare invalid character 01", .tags(.table))
+    func table__bare_invalid_character_01() throws {
         try invalidate(pathComponents: ["table", "bare-invalid-character-01"])
     }
 
-    @Test(.tags(.table))
-    func `[table] bare invalid character 02`() throws {
+    @Test("[table] bare invalid character 02", .tags(.table))
+    func table__bare_invalid_character_02() throws {
         try invalidate(pathComponents: ["table", "bare-invalid-character-02"])
     }
 
-    @Test(.tags(.table))
-    func `[table] dot`() throws {
+    @Test("[table] dot", .tags(.table))
+    func table__dot() throws {
         try invalidate(pathComponents: ["table", "dot"])
     }
 
-    @Test(.tags(.table))
-    func `[table] dotdot`() throws {
+    @Test("[table] dotdot", .tags(.table))
+    func table__dotdot() throws {
         try invalidate(pathComponents: ["table", "dotdot"])
     }
 
-    @Test(.tags(.table))
-    func `[table] duplicate key 01`() throws {
+    @Test("[table] duplicate key 01", .tags(.table))
+    func table__duplicate_key_01() throws {
         try invalidate(pathComponents: ["table", "duplicate-key-01"])
     }
 
-    @Test(.tags(.table))
-    func `[table] duplicate key 02`() throws {
+    @Test("[table] duplicate key 02", .tags(.table))
+    func table__duplicate_key_02() throws {
         try invalidate(pathComponents: ["table", "duplicate-key-02"])
     }
 
-    @Test(.tags(.table))
-    func `[table] duplicate key 03`() throws {
+    @Test("[table] duplicate key 03", .tags(.table))
+    func table__duplicate_key_03() throws {
         try invalidate(pathComponents: ["table", "duplicate-key-03"])
     }
 
-    @Test(.tags(.table))
-    func `[table] duplicate key 04`() throws {
+    @Test("[table] duplicate key 04", .tags(.table))
+    func table__duplicate_key_04() throws {
         try invalidate(pathComponents: ["table", "duplicate-key-04"])
     }
 
-    @Test(.tags(.table))
-    func `[table] duplicate key 05`() throws {
+    @Test("[table] duplicate key 05", .tags(.table))
+    func table__duplicate_key_05() throws {
         try invalidate(pathComponents: ["table", "duplicate-key-05"])
     }
 
-    @Test(.tags(.table))
-    func `[table] duplicate key 06`() throws {
+    @Test("[table] duplicate key 06", .tags(.table))
+    func table__duplicate_key_06() throws {
         try invalidate(pathComponents: ["table", "duplicate-key-06"])
     }
 
-    @Test(.tags(.table))
-    func `[table] duplicate key 07`() throws {
+    @Test("[table] duplicate key 07", .tags(.table))
+    func table__duplicate_key_07() throws {
         try invalidate(pathComponents: ["table", "duplicate-key-07"])
     }
 
-    @Test(.tags(.table))
-    func `[table] duplicate key 08`() throws {
+    @Test("[table] duplicate key 08", .tags(.table))
+    func table__duplicate_key_08() throws {
         try invalidate(pathComponents: ["table", "duplicate-key-08"])
     }
 
-    @Test(.tags(.table))
-    func `[table] duplicate key 09`() throws {
+    @Test("[table] duplicate key 09", .tags(.table))
+    func table__duplicate_key_09() throws {
         try invalidate(pathComponents: ["table", "duplicate-key-09"])
     }
 
-    @Test(.tags(.table))
-    func `[table] duplicate key 10`() throws {
+    @Test("[table] duplicate key 10", .tags(.table))
+    func table__duplicate_key_10() throws {
         try invalidate(pathComponents: ["table", "duplicate-key-10"])
     }
 
-    @Test(.tags(.table))
-    func `[table] empty`() throws {
+    @Test("[table] empty", .tags(.table))
+    func table__empty() throws {
         try invalidate(pathComponents: ["table", "empty"])
     }
 
-    @Test(.tags(.table))
-    func `[table] empty implicit table`() throws {
+    @Test("[table] empty implicit table", .tags(.table))
+    func table__empty_implicit_table() throws {
         try invalidate(pathComponents: ["table", "empty-implicit-table"])
     }
 
-    @Test(.tags(.table))
-    func `[table] equals sign`() throws {
+    @Test("[table] equals sign", .tags(.table))
+    func table__equals_sign() throws {
         try invalidate(pathComponents: ["table", "equals-sign"])
     }
 
-    @Test(.tags(.table))
-    func `[table] llbrace`() throws {
+    @Test("[table] llbrace", .tags(.table))
+    func table__llbrace() throws {
         try invalidate(pathComponents: ["table", "llbrace"])
     }
 
-    @Test(.tags(.table))
-    func `[table] multiline key 01`() throws {
+    @Test("[table] multiline key 01", .tags(.table))
+    func table__multiline_key_01() throws {
         try invalidate(pathComponents: ["table", "multiline-key-01"])
     }
 
-    @Test(.tags(.table))
-    func `[table] multiline key 02`() throws {
+    @Test("[table] multiline key 02", .tags(.table))
+    func table__multiline_key_02() throws {
         try invalidate(pathComponents: ["table", "multiline-key-02"])
     }
 
-    @Test(.tags(.table))
-    func `[table] nested brackets close`() throws {
+    @Test("[table] nested brackets close", .tags(.table))
+    func table__nested_brackets_close() throws {
         try invalidate(pathComponents: ["table", "nested-brackets-close"])
     }
 
-    @Test(.tags(.table))
-    func `[table] nested brackets open`() throws {
+    @Test("[table] nested brackets open", .tags(.table))
+    func table__nested_brackets_open() throws {
         try invalidate(pathComponents: ["table", "nested-brackets-open"])
     }
 
-    @Test(.tags(.table))
-    func `[table] newline 01`() throws {
+    @Test("[table] newline 01", .tags(.table))
+    func table__newline_01() throws {
         try invalidate(pathComponents: ["table", "newline-01"])
     }
 
-    @Test(.tags(.table))
-    func `[table] newline 02`() throws {
+    @Test("[table] newline 02", .tags(.table))
+    func table__newline_02() throws {
         try invalidate(pathComponents: ["table", "newline-02"])
     }
 
-    @Test(.tags(.table))
-    func `[table] newline 03`() throws {
+    @Test("[table] newline 03", .tags(.table))
+    func table__newline_03() throws {
         try invalidate(pathComponents: ["table", "newline-03"])
     }
 
-    @Test(.tags(.table))
-    func `[table] newline 04`() throws {
+    @Test("[table] newline 04", .tags(.table))
+    func table__newline_04() throws {
         try invalidate(pathComponents: ["table", "newline-04"])
     }
 
-    @Test(.tags(.table))
-    func `[table] newline 05`() throws {
+    @Test("[table] newline 05", .tags(.table))
+    func table__newline_05() throws {
         try invalidate(pathComponents: ["table", "newline-05"])
     }
 
-    @Test(.tags(.table))
-    func `[table] no close 01`() throws {
+    @Test("[table] no close 01", .tags(.table))
+    func table__no_close_01() throws {
         try invalidate(pathComponents: ["table", "no-close-01"])
     }
 
-    @Test(.tags(.table))
-    func `[table] no close 02`() throws {
+    @Test("[table] no close 02", .tags(.table))
+    func table__no_close_02() throws {
         try invalidate(pathComponents: ["table", "no-close-02"])
     }
 
-    @Test(.tags(.table))
-    func `[table] no close 03`() throws {
+    @Test("[table] no close 03", .tags(.table))
+    func table__no_close_03() throws {
         try invalidate(pathComponents: ["table", "no-close-03"])
     }
 
-    @Test(.tags(.table))
-    func `[table] no close 04`() throws {
+    @Test("[table] no close 04", .tags(.table))
+    func table__no_close_04() throws {
         try invalidate(pathComponents: ["table", "no-close-04"])
     }
 
-    @Test(.tags(.table))
-    func `[table] no close 05`() throws {
+    @Test("[table] no close 05", .tags(.table))
+    func table__no_close_05() throws {
         try invalidate(pathComponents: ["table", "no-close-05"])
     }
 
-    @Test(.tags(.table))
-    func `[table] no close 06`() throws {
+    @Test("[table] no close 06", .tags(.table))
+    func table__no_close_06() throws {
         try invalidate(pathComponents: ["table", "no-close-06"])
     }
 
-    @Test(.tags(.table))
-    func `[table] no close 07`() throws {
+    @Test("[table] no close 07", .tags(.table))
+    func table__no_close_07() throws {
         try invalidate(pathComponents: ["table", "no-close-07"])
     }
 
-    @Test(.tags(.table))
-    func `[table] no close 08`() throws {
+    @Test("[table] no close 08", .tags(.table))
+    func table__no_close_08() throws {
         try invalidate(pathComponents: ["table", "no-close-08"])
     }
 
-    @Test(.tags(.table))
-    func `[table] no close 09`() throws {
+    @Test("[table] no close 09", .tags(.table))
+    func table__no_close_09() throws {
         try invalidate(pathComponents: ["table", "no-close-09"])
     }
 
-    @Test(.tags(.table))
-    func `[table] overwrite array in parent`() throws {
+    @Test("[table] overwrite array in parent", .tags(.table))
+    func table__overwrite_array_in_parent() throws {
         try invalidate(pathComponents: ["table", "overwrite-array-in-parent"])
     }
 
-    @Test(.tags(.table))
-    func `[table] overwrite bool with array`() throws {
+    @Test("[table] overwrite bool with array", .tags(.table))
+    func table__overwrite_bool_with_array() throws {
         try invalidate(pathComponents: ["table", "overwrite-bool-with-array"])
     }
 
-    @Test(.tags(.table))
-    func `[table] overwrite with deep table`() throws {
+    @Test("[table] overwrite with deep table", .tags(.table))
+    func table__overwrite_with_deep_table() throws {
         try invalidate(pathComponents: ["table", "overwrite-with-deep-table"])
     }
 
-    @Test(.tags(.table))
-    func `[table] redefine 01`() throws {
+    @Test("[table] redefine 01", .tags(.table))
+    func table__redefine_01() throws {
         try invalidate(pathComponents: ["table", "redefine-01"])
     }
 
-    @Test(.tags(.table))
-    func `[table] redefine 02`() throws {
+    @Test("[table] redefine 02", .tags(.table))
+    func table__redefine_02() throws {
         try invalidate(pathComponents: ["table", "redefine-02"])
     }
 
-    @Test(.tags(.table))
-    func `[table] redefine 03`() throws {
+    @Test("[table] redefine 03", .tags(.table))
+    func table__redefine_03() throws {
         try invalidate(pathComponents: ["table", "redefine-03"])
     }
 
-    @Test(.tags(.table))
-    func `[table] rrbrace`() throws {
+    @Test("[table] rrbrace", .tags(.table))
+    func table__rrbrace() throws {
         try invalidate(pathComponents: ["table", "rrbrace"])
     }
 
-    @Test(.tags(.table))
-    func `[table] super twice`() throws {
+    @Test("[table] super twice", .tags(.table))
+    func table__super_twice() throws {
         try invalidate(pathComponents: ["table", "super-twice"])
     }
 
-    @Test(.tags(.table))
-    func `[table] text after table`() throws {
+    @Test("[table] text after table", .tags(.table))
+    func table__text_after_table() throws {
         try invalidate(pathComponents: ["table", "text-after-table"])
     }
 
-    @Test(.tags(.table))
-    func `[table] trailing dot`() throws {
+    @Test("[table] trailing dot", .tags(.table))
+    func table__trailing_dot() throws {
         try invalidate(pathComponents: ["table", "trailing-dot"])
     }
 
-    @Test(.tags(.table))
-    func `[table] whitespace`() throws {
+    @Test("[table] whitespace", .tags(.table))
+    func table__whitespace() throws {
         try invalidate(pathComponents: ["table", "whitespace"])
     }
 
-    @Test(.tags(.table))
-    func `[table] with pound`() throws {
+    @Test("[table] with pound", .tags(.table))
+    func table__with_pound() throws {
         try invalidate(pathComponents: ["table", "with-pound"])
     }
 }
diff --git a/Tests/TOMLDecoderTests/LeafValueDecodingTests.Generated.swift b/Tests/TOMLDecoderTests/LeafValueDecodingTests.Generated.swift
index 4ecd8aab..f8a96e45 100644
--- a/Tests/TOMLDecoderTests/LeafValueDecodingTests.Generated.swift
+++ b/Tests/TOMLDecoderTests/LeafValueDecodingTests.Generated.swift
@@ -5,8 +5,9 @@ import Foundation
 import Testing
 import TOMLDecoder
 
+@Suite
 struct LeafValueDecodingTests {
-    @Test func `boolean as bool`() throws {
+    @Test func booleanAsBool() throws {
         struct Test: Decodable, Equatable {
             let boolean: Bool
             let booleans: [Bool]
@@ -41,7 +42,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func `string as string`() throws {
+    @Test func stringAsString() throws {
         struct Test: Decodable, Equatable {
             let string: String
             let strings: [String]
@@ -76,7 +77,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func `integer as int`() throws {
+    @Test func integerAsInt() throws {
         struct Test: Decodable, Equatable {
             let integer: Int
             let integers: [Int]
@@ -111,7 +112,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func `integer as int 8`() throws {
+    @Test func integerAsInt8() throws {
         struct Test: Decodable, Equatable {
             let integer: Int8
             let integers: [Int8]
@@ -146,7 +147,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func `integer as int 16`() throws {
+    @Test func integerAsInt16() throws {
         struct Test: Decodable, Equatable {
             let integer: Int16
             let integers: [Int16]
@@ -181,7 +182,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func `integer as int 32`() throws {
+    @Test func integerAsInt32() throws {
         struct Test: Decodable, Equatable {
             let integer: Int32
             let integers: [Int32]
@@ -216,7 +217,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func `integer as U int`() throws {
+    @Test func integerAsUInt() throws {
         struct Test: Decodable, Equatable {
             let integer: UInt
             let integers: [UInt]
@@ -251,7 +252,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func `integer as U int 8`() throws {
+    @Test func integerAsUInt8() throws {
         struct Test: Decodable, Equatable {
             let integer: UInt8
             let integers: [UInt8]
@@ -286,7 +287,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func `integer as U int 16`() throws {
+    @Test func integerAsUInt16() throws {
         struct Test: Decodable, Equatable {
             let integer: UInt16
             let integers: [UInt16]
@@ -321,7 +322,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func `integer as U int 32`() throws {
+    @Test func integerAsUInt32() throws {
         struct Test: Decodable, Equatable {
             let integer: UInt32
             let integers: [UInt32]
@@ -356,7 +357,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func `integer as U int 64`() throws {
+    @Test func integerAsUInt64() throws {
         struct Test: Decodable, Equatable {
             let integer: UInt64
             let integers: [UInt64]
@@ -391,7 +392,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func `float as float`() throws {
+    @Test func floatAsFloat() throws {
         struct Test: Decodable, Equatable {
             let float: Float
             let floats: [Float]
@@ -426,7 +427,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func `float as double`() throws {
+    @Test func floatAsDouble() throws {
         struct Test: Decodable, Equatable {
             let float: Double
             let floats: [Double]
@@ -461,7 +462,7 @@ struct LeafValueDecodingTests {
         #expect(result == expectation)
     }
 
-    @Test func `all the native dates`() throws {
+    @Test func allTheNativeDates() throws {
         struct Test: Decodable, Equatable {
             let localDate: LocalDate
             let localDateFromLocalDateTime: LocalDate
diff --git a/Tests/TOMLDecoderTests/TOMLDecoderTests.swift b/Tests/TOMLDecoderTests/TOMLDecoderTests.swift
index a1aefed1..55663ce4 100644
--- a/Tests/TOMLDecoderTests/TOMLDecoderTests.swift
+++ b/Tests/TOMLDecoderTests/TOMLDecoderTests.swift
@@ -3,8 +3,9 @@ import Resources
 import Testing
 @testable import TOMLDecoder
 
+@Suite
 struct TOMLDecoderTests {
-    @Test func `basic generated codables`() throws {
+    @Test func basicGeneratedCodables() throws {
         struct Player: Codable, Equatable {
             let id: String
             let health: Int64
@@ -35,7 +36,7 @@ struct TOMLDecoderTests {
         #expect(result == expectation)
     }
 
-    @Test func `decoding container keyed`() throws {
+    @Test func decodingContainerKeyed() throws {
         struct Player: Decodable, Equatable {
             let id: String
             let health: Int64
@@ -73,7 +74,7 @@ struct TOMLDecoderTests {
         #expect(result == expectation)
     }
 
-    @Test func `nested unkeyed decoding container`() throws {
+    @Test func nestedUnkeyedDecodingContainer() throws {
         struct Player: Decodable, Equatable {
             let id: String
             let health: Int64
@@ -125,7 +126,7 @@ struct TOMLDecoderTests {
         #expect(result == expectation)
     }
 
-    @Test func `lenient integer decoding strategy`() throws {
+    @Test func lenientIntegerDecodingStrategy() throws {
         struct Player: Codable, Equatable {
             let id: String
             let health: Int
@@ -144,7 +145,7 @@ struct TOMLDecoderTests {
     }
 
     @Test
-    func `foundation date decoding`() throws {
+    func foundationDateDecoding() throws {
         struct Player: Codable, Equatable {
             let id: String
             let signUpDate: Date
@@ -164,7 +165,7 @@ struct TOMLDecoderTests {
     }
 
     @Test
-    func `foundation date components from local date decoding`() throws {
+    func foundationDateComponentsFromLocalDateDecoding() throws {
         struct Player: Codable, Equatable {
             let id: String
             let signUpDate: DateComponents
@@ -184,7 +185,7 @@ struct TOMLDecoderTests {
     }
 
     @Test
-    func `foundation date components from local time decoding`() throws {
+    func foundationDateComponentsFromLocalTimeDecoding() throws {
         struct Player: Codable, Equatable {
             let id: String
             let signUpTime: DateComponents
@@ -204,7 +205,7 @@ struct TOMLDecoderTests {
     }
 
     @Test
-    func `foundation date components from local date time decoding`() throws {
+    func foundationDateComponentsFromLocalDateTimeDecoding() throws {
         struct Player: Codable, Equatable {
             let id: String
             let signUpTime: DateComponents
@@ -224,7 +225,7 @@ struct TOMLDecoderTests {
         #expect(result == expectation)
     }
 
-    @Test func `decoding snake case key strategy`() throws {
+    @Test func decodingSnakeCaseKeyStrategy() throws {
         struct Player: Codable, Equatable {
             let id: String
             let firstProfession: String
@@ -244,7 +245,7 @@ struct TOMLDecoderTests {
         #expect(result == expectation)
     }
 
-    @Test func `decoding custom key strategy`() throws {
+    @Test func decodingCustomKeyStrategy() throws {
         struct Player: Codable, Equatable {
             let id: String
             let profession: String
@@ -265,7 +266,7 @@ struct TOMLDecoderTests {
         #expect(result == expectation)
     }
 
-    @Test func `array of strings parsing`() throws {
+    @Test func arrayOfStringsParsing() throws {
         struct AppConfig: Codable, Equatable {
             let name: String
             let version: String
@@ -306,7 +307,7 @@ struct TOMLDecoderTests {
         #expect(result == expectation)
     }
 
-    @Test func `super decoder`() throws {
+    @Test func superDecoder() throws {
         class Player: Codable {
             let id: String
             let health: Int
@@ -337,7 +338,7 @@ struct TOMLDecoderTests {
         _ = try decoder.decode(LocalPlayer.self, from: toml)
     }
 
-    @Test func `toml io example`() throws {
+    @Test func tomlIoExample() throws {
         let toml = """
         # This is a TOML document
 
@@ -420,7 +421,7 @@ struct TOMLDecoderTests {
         #expect(result == expectation)
     }
 
-    @Test func `mixing containers`() throws {
+    @Test func mixingContainers() throws {
         struct Test: Decodable, Equatable {
             let numbers: [[Int64]]
             let strings: TOMLArray
@@ -442,7 +443,7 @@ struct TOMLDecoderTests {
         #expect(result.numbers == [[1, 2], [3, 4]])
     }
 
-    @Test func `optional fields`() throws {
+    @Test func optionalFields() throws {
         struct Test: Codable, Equatable {
             let a: Int64?
             let b: Double?
@@ -469,7 +470,7 @@ struct TOMLDecoderTests {
         #expect(result2 == Test(a: nil, b: 1.0, c: "claude"))
     }
 
-    @Test func `single value container`() throws {
+    @Test func singleValueContainer() throws {
         enum Language: String, Codable {
             case swift
             case mojo
diff --git a/Tests/TOMLDecoderTests/TOMLTableKeyMembershipTests.swift b/Tests/TOMLDecoderTests/TOMLTableKeyMembershipTests.swift
index afe6e884..ee9484be 100644
--- a/Tests/TOMLDecoderTests/TOMLTableKeyMembershipTests.swift
+++ b/Tests/TOMLDecoderTests/TOMLTableKeyMembershipTests.swift
@@ -18,15 +18,16 @@ health = 123
 id = "cde"
 health = 456
 """
+@Suite
 struct TOMLTableKeyMembershipTests {
     @Test
-    func `all keys for root table`() throws {
+    func allKeysForRootTable() throws {
         let table = try TOMLTable(source: toml)
         #expect(table.keys == ["a", "b", "players", "c"])
     }
 
     @Test
-    func `root table key contains`() throws {
+    func rootTableKeyContains() throws {
         let table = try TOMLTable(source: toml)
         #expect(table.keys == ["a", "b", "players", "c"])
         #expect(table.contains(key: "a"))
diff --git a/Tests/TOMLDecoderTests/ValidationTests.Generated.swift b/Tests/TOMLDecoderTests/ValidationTests.Generated.swift
index cee58330..6f516b08 100644
--- a/Tests/TOMLDecoderTests/ValidationTests.Generated.swift
+++ b/Tests/TOMLDecoderTests/ValidationTests.Generated.swift
@@ -5,6 +5,7 @@ import Foundation
 import Testing
 import TOMLDecoder
 
+@Suite
 struct TOMLValidationTests {
     private var directoryURL: URL {
         URL(fileURLWithPath: #filePath)
@@ -19,1073 +20,1073 @@ struct TOMLValidationTests {
         try TOMLComplianceSupport.verifyValidFixture(jsonURL: jsonURL, tomlURL: tomlURL, sourceLocation: sourceLocation)
     }
 
-    @Test(.tags(.array))
-    func `[array] array`() throws {
+    @Test("[array] array", .tags(.array))
+    func array__array() throws {
         try verifyByFixture(pathComponents: ["array", "array"])
     }
 
-    @Test(.tags(.array))
-    func `[array] array subtables`() throws {
+    @Test("[array] array subtables", .tags(.array))
+    func array__array_subtables() throws {
         try verifyByFixture(pathComponents: ["array", "array-subtables"])
     }
 
-    @Test(.tags(.array))
-    func `[array] bool`() throws {
+    @Test("[array] bool", .tags(.array))
+    func array__bool() throws {
         try verifyByFixture(pathComponents: ["array", "bool"])
     }
 
-    @Test(.tags(.array))
-    func `[array] empty`() throws {
+    @Test("[array] empty", .tags(.array))
+    func array__empty() throws {
         try verifyByFixture(pathComponents: ["array", "empty"])
     }
 
-    @Test(.tags(.array))
-    func `[array] hetergeneous`() throws {
+    @Test("[array] hetergeneous", .tags(.array))
+    func array__hetergeneous() throws {
         try verifyByFixture(pathComponents: ["array", "hetergeneous"])
     }
 
-    @Test(.tags(.array))
-    func `[array] mixed int array`() throws {
+    @Test("[array] mixed int array", .tags(.array))
+    func array__mixed_int_array() throws {
         try verifyByFixture(pathComponents: ["array", "mixed-int-array"])
     }
 
-    @Test(.tags(.array))
-    func `[array] mixed int float`() throws {
+    @Test("[array] mixed int float", .tags(.array))
+    func array__mixed_int_float() throws {
         try verifyByFixture(pathComponents: ["array", "mixed-int-float"])
     }
 
-    @Test(.tags(.array))
-    func `[array] mixed int string`() throws {
+    @Test("[array] mixed int string", .tags(.array))
+    func array__mixed_int_string() throws {
         try verifyByFixture(pathComponents: ["array", "mixed-int-string"])
     }
 
-    @Test(.tags(.array))
-    func `[array] mixed string table`() throws {
+    @Test("[array] mixed string table", .tags(.array))
+    func array__mixed_string_table() throws {
         try verifyByFixture(pathComponents: ["array", "mixed-string-table"])
     }
 
-    @Test(.tags(.array))
-    func `[array] nested`() throws {
+    @Test("[array] nested", .tags(.array))
+    func array__nested() throws {
         try verifyByFixture(pathComponents: ["array", "nested"])
     }
 
-    @Test(.tags(.array))
-    func `[array] nested double`() throws {
+    @Test("[array] nested double", .tags(.array))
+    func array__nested_double() throws {
         try verifyByFixture(pathComponents: ["array", "nested-double"])
     }
 
-    @Test(.tags(.array))
-    func `[array] nested inline table`() throws {
+    @Test("[array] nested inline table", .tags(.array))
+    func array__nested_inline_table() throws {
         try verifyByFixture(pathComponents: ["array", "nested-inline-table"])
     }
 
-    @Test(.tags(.array))
-    func `[array] nospaces`() throws {
+    @Test("[array] nospaces", .tags(.array))
+    func array__nospaces() throws {
         try verifyByFixture(pathComponents: ["array", "nospaces"])
     }
 
-    @Test(.tags(.array))
-    func `[array] open parent table`() throws {
+    @Test("[array] open parent table", .tags(.array))
+    func array__open_parent_table() throws {
         try verifyByFixture(pathComponents: ["array", "open-parent-table"])
     }
 
-    @Test(.tags(.array))
-    func `[array] string quote comma 01`() throws {
+    @Test("[array] string quote comma 01", .tags(.array))
+    func array__string_quote_comma_01() throws {
         try verifyByFixture(pathComponents: ["array", "string-quote-comma-01"])
     }
 
-    @Test(.tags(.array))
-    func `[array] string quote comma 02`() throws {
+    @Test("[array] string quote comma 02", .tags(.array))
+    func array__string_quote_comma_02() throws {
         try verifyByFixture(pathComponents: ["array", "string-quote-comma-02"])
     }
 
-    @Test(.tags(.array))
-    func `[array] string with comma 01`() throws {
+    @Test("[array] string with comma 01", .tags(.array))
+    func array__string_with_comma_01() throws {
         try verifyByFixture(pathComponents: ["array", "string-with-comma-01"])
     }
 
-    @Test(.tags(.array))
-    func `[array] string with comma 02`() throws {
+    @Test("[array] string with comma 02", .tags(.array))
+    func array__string_with_comma_02() throws {
         try verifyByFixture(pathComponents: ["array", "string-with-comma-02"])
     }
 
-    @Test(.tags(.array))
-    func `[array] strings`() throws {
+    @Test("[array] strings", .tags(.array))
+    func array__strings() throws {
         try verifyByFixture(pathComponents: ["array", "strings"])
     }
 
-    @Test(.tags(.array))
-    func `[array] table array string backslash`() throws {
+    @Test("[array] table array string backslash", .tags(.array))
+    func array__table_array_string_backslash() throws {
         try verifyByFixture(pathComponents: ["array", "table-array-string-backslash"])
     }
 
-    @Test(.tags(.array))
-    func `[array] trailing comma`() throws {
+    @Test("[array] trailing comma", .tags(.array))
+    func array__trailing_comma() throws {
         try verifyByFixture(pathComponents: ["array", "trailing-comma"])
     }
 
-    @Test(.tags(.bool))
-    func `[bool] bool`() throws {
+    @Test("[bool] bool", .tags(.bool))
+    func bool__bool() throws {
         try verifyByFixture(pathComponents: ["bool", "bool"])
     }
 
-    @Test(.tags(.comment))
-    func `[comment] after literal no ws`() throws {
+    @Test("[comment] after literal no ws", .tags(.comment))
+    func comment__after_literal_no_ws() throws {
         try verifyByFixture(pathComponents: ["comment", "after-literal-no-ws"])
     }
 
-    @Test(.tags(.comment))
-    func `[comment] at eof`() throws {
+    @Test("[comment] at eof", .tags(.comment))
+    func comment__at_eof() throws {
         try verifyByFixture(pathComponents: ["comment", "at-eof"])
     }
 
-    @Test(.tags(.comment))
-    func `[comment] at eof2`() throws {
+    @Test("[comment] at eof2", .tags(.comment))
+    func comment__at_eof2() throws {
         try verifyByFixture(pathComponents: ["comment", "at-eof2"])
     }
 
-    @Test(.tags(.comment))
-    func `[comment] everywhere`() throws {
+    @Test("[comment] everywhere", .tags(.comment))
+    func comment__everywhere() throws {
         try verifyByFixture(pathComponents: ["comment", "everywhere"])
     }
 
-    @Test(.tags(.comment))
-    func `[comment] noeol`() throws {
+    @Test("[comment] noeol", .tags(.comment))
+    func comment__noeol() throws {
         try verifyByFixture(pathComponents: ["comment", "noeol"])
     }
 
-    @Test(.tags(.comment))
-    func `[comment] nonascii`() throws {
+    @Test("[comment] nonascii", .tags(.comment))
+    func comment__nonascii() throws {
         try verifyByFixture(pathComponents: ["comment", "nonascii"])
     }
 
-    @Test(.tags(.comment))
-    func `[comment] tricky`() throws {
+    @Test("[comment] tricky", .tags(.comment))
+    func comment__tricky() throws {
         try verifyByFixture(pathComponents: ["comment", "tricky"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] datetime`() throws {
+    @Test("[datetime] datetime", .tags(.datetime))
+    func datetime__datetime() throws {
         try verifyByFixture(pathComponents: ["datetime", "datetime"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] edge`() throws {
+    @Test("[datetime] edge", .tags(.datetime))
+    func datetime__edge() throws {
         try verifyByFixture(pathComponents: ["datetime", "edge"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] invalid date in string`() throws {
+    @Test("[datetime] invalid date in string", .tags(.datetime))
+    func datetime__invalid_date_in_string() throws {
         try verifyByFixture(pathComponents: ["datetime", "invalid-date-in-string"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] leap year`() throws {
+    @Test("[datetime] leap year", .tags(.datetime))
+    func datetime__leap_year() throws {
         try verifyByFixture(pathComponents: ["datetime", "leap-year"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] local`() throws {
+    @Test("[datetime] local", .tags(.datetime))
+    func datetime__local() throws {
         try verifyByFixture(pathComponents: ["datetime", "local"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] local date`() throws {
+    @Test("[datetime] local date", .tags(.datetime))
+    func datetime__local_date() throws {
         try verifyByFixture(pathComponents: ["datetime", "local-date"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] local time`() throws {
+    @Test("[datetime] local time", .tags(.datetime))
+    func datetime__local_time() throws {
         try verifyByFixture(pathComponents: ["datetime", "local-time"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] milliseconds`() throws {
+    @Test("[datetime] milliseconds", .tags(.datetime))
+    func datetime__milliseconds() throws {
         try verifyByFixture(pathComponents: ["datetime", "milliseconds"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] no seconds`() throws {
+    @Test("[datetime] no seconds", .tags(.datetime))
+    func datetime__no_seconds() throws {
         try verifyByFixture(pathComponents: ["datetime", "no-seconds"])
     }
 
-    @Test(.tags(.datetime))
-    func `[datetime] timezone`() throws {
+    @Test("[datetime] timezone", .tags(.datetime))
+    func datetime__timezone() throws {
         try verifyByFixture(pathComponents: ["datetime", "timezone"])
     }
 
-    @Test
-    func `empty crlf`() throws {
+    @Test("empty crlf")
+    func empty_crlf() throws {
         try verifyByFixture(pathComponents: ["empty-crlf"])
     }
 
-    @Test
-    func `empty lf`() throws {
+    @Test("empty lf")
+    func empty_lf() throws {
         try verifyByFixture(pathComponents: ["empty-lf"])
     }
 
-    @Test
-    func `empty nothing`() throws {
+    @Test("empty nothing")
+    func empty_nothing() throws {
         try verifyByFixture(pathComponents: ["empty-nothing"])
     }
 
-    @Test
-    func `empty space`() throws {
+    @Test("empty space")
+    func empty_space() throws {
         try verifyByFixture(pathComponents: ["empty-space"])
     }
 
-    @Test
-    func `empty tab`() throws {
+    @Test("empty tab")
+    func empty_tab() throws {
         try verifyByFixture(pathComponents: ["empty-tab"])
     }
 
-    @Test
+    @Test("example")
     func example() throws {
         try verifyByFixture(pathComponents: ["example"])
     }
 
-    @Test(.tags(.float))
-    func `[float] exponent`() throws {
+    @Test("[float] exponent", .tags(.float))
+    func float__exponent() throws {
         try verifyByFixture(pathComponents: ["float", "exponent"])
     }
 
-    @Test(.tags(.float))
-    func `[float] float`() throws {
+    @Test("[float] float", .tags(.float))
+    func float__float() throws {
         try verifyByFixture(pathComponents: ["float", "float"])
     }
 
-    @Test(.tags(.float))
-    func `[float] inf and nan`() throws {
+    @Test("[float] inf and nan", .tags(.float))
+    func float__inf_and_nan() throws {
         try verifyByFixture(pathComponents: ["float", "inf-and-nan"])
     }
 
-    @Test(.tags(.float))
-    func `[float] long`() throws {
+    @Test("[float] long", .tags(.float))
+    func float__long() throws {
         try verifyByFixture(pathComponents: ["float", "long"])
     }
 
-    @Test(.tags(.float))
-    func `[float] max int`() throws {
+    @Test("[float] max int", .tags(.float))
+    func float__max_int() throws {
         try verifyByFixture(pathComponents: ["float", "max-int"])
     }
 
-    @Test(.tags(.float))
-    func `[float] underscore`() throws {
+    @Test("[float] underscore", .tags(.float))
+    func float__underscore() throws {
         try verifyByFixture(pathComponents: ["float", "underscore"])
     }
 
-    @Test(.tags(.float))
-    func `[float] zero`() throws {
+    @Test("[float] zero", .tags(.float))
+    func float__zero() throws {
         try verifyByFixture(pathComponents: ["float", "zero"])
     }
 
-    @Test
-    func `implicit and explicit after`() throws {
+    @Test("implicit and explicit after")
+    func implicit_and_explicit_after() throws {
         try verifyByFixture(pathComponents: ["implicit-and-explicit-after"])
     }
 
-    @Test
-    func `implicit and explicit before`() throws {
+    @Test("implicit and explicit before")
+    func implicit_and_explicit_before() throws {
         try verifyByFixture(pathComponents: ["implicit-and-explicit-before"])
     }
 
-    @Test
-    func `implicit groups`() throws {
+    @Test("implicit groups")
+    func implicit_groups() throws {
         try verifyByFixture(pathComponents: ["implicit-groups"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] array 01`() throws {
+    @Test("[inline-table] array 01", .tags(.inline_table))
+    func inline_table__array_01() throws {
         try verifyByFixture(pathComponents: ["inline-table", "array-01"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] array 02`() throws {
+    @Test("[inline-table] array 02", .tags(.inline_table))
+    func inline_table__array_02() throws {
         try verifyByFixture(pathComponents: ["inline-table", "array-02"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] array 03`() throws {
+    @Test("[inline-table] array 03", .tags(.inline_table))
+    func inline_table__array_03() throws {
         try verifyByFixture(pathComponents: ["inline-table", "array-03"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] bool`() throws {
+    @Test("[inline-table] bool", .tags(.inline_table))
+    func inline_table__bool() throws {
         try verifyByFixture(pathComponents: ["inline-table", "bool"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] empty`() throws {
+    @Test("[inline-table] empty", .tags(.inline_table))
+    func inline_table__empty() throws {
         try verifyByFixture(pathComponents: ["inline-table", "empty"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] end in bool`() throws {
+    @Test("[inline-table] end in bool", .tags(.inline_table))
+    func inline_table__end_in_bool() throws {
         try verifyByFixture(pathComponents: ["inline-table", "end-in-bool"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] inline table`() throws {
+    @Test("[inline-table] inline table", .tags(.inline_table))
+    func inline_table__inline_table() throws {
         try verifyByFixture(pathComponents: ["inline-table", "inline-table"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] key dotted 01`() throws {
+    @Test("[inline-table] key dotted 01", .tags(.inline_table))
+    func inline_table__key_dotted_01() throws {
         try verifyByFixture(pathComponents: ["inline-table", "key-dotted-01"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] key dotted 02`() throws {
+    @Test("[inline-table] key dotted 02", .tags(.inline_table))
+    func inline_table__key_dotted_02() throws {
         try verifyByFixture(pathComponents: ["inline-table", "key-dotted-02"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] key dotted 03`() throws {
+    @Test("[inline-table] key dotted 03", .tags(.inline_table))
+    func inline_table__key_dotted_03() throws {
         try verifyByFixture(pathComponents: ["inline-table", "key-dotted-03"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] key dotted 04`() throws {
+    @Test("[inline-table] key dotted 04", .tags(.inline_table))
+    func inline_table__key_dotted_04() throws {
         try verifyByFixture(pathComponents: ["inline-table", "key-dotted-04"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] key dotted 05`() throws {
+    @Test("[inline-table] key dotted 05", .tags(.inline_table))
+    func inline_table__key_dotted_05() throws {
         try verifyByFixture(pathComponents: ["inline-table", "key-dotted-05"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] key dotted 06`() throws {
+    @Test("[inline-table] key dotted 06", .tags(.inline_table))
+    func inline_table__key_dotted_06() throws {
         try verifyByFixture(pathComponents: ["inline-table", "key-dotted-06"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] key dotted 07`() throws {
+    @Test("[inline-table] key dotted 07", .tags(.inline_table))
+    func inline_table__key_dotted_07() throws {
         try verifyByFixture(pathComponents: ["inline-table", "key-dotted-07"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] multiline`() throws {
+    @Test("[inline-table] multiline", .tags(.inline_table))
+    func inline_table__multiline() throws {
         try verifyByFixture(pathComponents: ["inline-table", "multiline"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] nest`() throws {
+    @Test("[inline-table] nest", .tags(.inline_table))
+    func inline_table__nest() throws {
         try verifyByFixture(pathComponents: ["inline-table", "nest"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] newline`() throws {
+    @Test("[inline-table] newline", .tags(.inline_table))
+    func inline_table__newline() throws {
         try verifyByFixture(pathComponents: ["inline-table", "newline"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] newline comment`() throws {
+    @Test("[inline-table] newline comment", .tags(.inline_table))
+    func inline_table__newline_comment() throws {
         try verifyByFixture(pathComponents: ["inline-table", "newline-comment"])
     }
 
-    @Test(.tags(.inline_table))
-    func `[inline-table] spaces`() throws {
+    @Test("[inline-table] spaces", .tags(.inline_table))
+    func inline_table__spaces() throws {
         try verifyByFixture(pathComponents: ["inline-table", "spaces"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] float64 max`() throws {
+    @Test("[integer] float64 max", .tags(.integer))
+    func integer__float64_max() throws {
         try verifyByFixture(pathComponents: ["integer", "float64-max"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] integer`() throws {
+    @Test("[integer] integer", .tags(.integer))
+    func integer__integer() throws {
         try verifyByFixture(pathComponents: ["integer", "integer"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] literals`() throws {
+    @Test("[integer] literals", .tags(.integer))
+    func integer__literals() throws {
         try verifyByFixture(pathComponents: ["integer", "literals"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] long`() throws {
+    @Test("[integer] long", .tags(.integer))
+    func integer__long() throws {
         try verifyByFixture(pathComponents: ["integer", "long"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] underscore`() throws {
+    @Test("[integer] underscore", .tags(.integer))
+    func integer__underscore() throws {
         try verifyByFixture(pathComponents: ["integer", "underscore"])
     }
 
-    @Test(.tags(.integer))
-    func `[integer] zero`() throws {
+    @Test("[integer] zero", .tags(.integer))
+    func integer__zero() throws {
         try verifyByFixture(pathComponents: ["integer", "zero"])
     }
 
-    @Test(.tags(.key))
-    func `[key] alphanum`() throws {
+    @Test("[key] alphanum", .tags(.key))
+    func key__alphanum() throws {
         try verifyByFixture(pathComponents: ["key", "alphanum"])
     }
 
-    @Test(.tags(.key))
-    func `[key] case sensitive`() throws {
+    @Test("[key] case sensitive", .tags(.key))
+    func key__case_sensitive() throws {
         try verifyByFixture(pathComponents: ["key", "case-sensitive"])
     }
 
-    @Test(.tags(.key))
-    func `[key] dotted 01`() throws {
+    @Test("[key] dotted 01", .tags(.key))
+    func key__dotted_01() throws {
         try verifyByFixture(pathComponents: ["key", "dotted-01"])
     }
 
-    @Test(.tags(.key))
-    func `[key] dotted 02`() throws {
+    @Test("[key] dotted 02", .tags(.key))
+    func key__dotted_02() throws {
         try verifyByFixture(pathComponents: ["key", "dotted-02"])
     }
 
-    @Test(.tags(.key))
-    func `[key] dotted 03`() throws {
+    @Test("[key] dotted 03", .tags(.key))
+    func key__dotted_03() throws {
         try verifyByFixture(pathComponents: ["key", "dotted-03"])
     }
 
-    @Test(.tags(.key))
-    func `[key] dotted 04`() throws {
+    @Test("[key] dotted 04", .tags(.key))
+    func key__dotted_04() throws {
         try verifyByFixture(pathComponents: ["key", "dotted-04"])
     }
 
-    @Test(.tags(.key))
-    func `[key] dotted empty`() throws {
+    @Test("[key] dotted empty", .tags(.key))
+    func key__dotted_empty() throws {
         try verifyByFixture(pathComponents: ["key", "dotted-empty"])
     }
 
-    @Test(.tags(.key))
-    func `[key] empty 01`() throws {
+    @Test("[key] empty 01", .tags(.key))
+    func key__empty_01() throws {
         try verifyByFixture(pathComponents: ["key", "empty-01"])
     }
 
-    @Test(.tags(.key))
-    func `[key] empty 02`() throws {
+    @Test("[key] empty 02", .tags(.key))
+    func key__empty_02() throws {
         try verifyByFixture(pathComponents: ["key", "empty-02"])
     }
 
-    @Test(.tags(.key))
-    func `[key] empty 03`() throws {
+    @Test("[key] empty 03", .tags(.key))
+    func key__empty_03() throws {
         try verifyByFixture(pathComponents: ["key", "empty-03"])
     }
 
-    @Test(.tags(.key))
-    func `[key] equals nospace`() throws {
+    @Test("[key] equals nospace", .tags(.key))
+    func key__equals_nospace() throws {
         try verifyByFixture(pathComponents: ["key", "equals-nospace"])
     }
 
-    @Test(.tags(.key))
-    func `[key] escapes`() throws {
+    @Test("[key] escapes", .tags(.key))
+    func key__escapes() throws {
         try verifyByFixture(pathComponents: ["key", "escapes"])
     }
 
-    @Test(.tags(.key))
-    func `[key] like date`() throws {
+    @Test("[key] like date", .tags(.key))
+    func key__like_date() throws {
         try verifyByFixture(pathComponents: ["key", "like-date"])
     }
 
-    @Test(.tags(.key))
-    func `[key] numeric 01`() throws {
+    @Test("[key] numeric 01", .tags(.key))
+    func key__numeric_01() throws {
         try verifyByFixture(pathComponents: ["key", "numeric-01"])
     }
 
-    @Test(.tags(.key))
-    func `[key] numeric 02`() throws {
+    @Test("[key] numeric 02", .tags(.key))
+    func key__numeric_02() throws {
         try verifyByFixture(pathComponents: ["key", "numeric-02"])
     }
 
-    @Test(.tags(.key))
-    func `[key] numeric 03`() throws {
+    @Test("[key] numeric 03", .tags(.key))
+    func key__numeric_03() throws {
         try verifyByFixture(pathComponents: ["key", "numeric-03"])
     }
 
-    @Test(.tags(.key))
-    func `[key] numeric 04`() throws {
+    @Test("[key] numeric 04", .tags(.key))
+    func key__numeric_04() throws {
         try verifyByFixture(pathComponents: ["key", "numeric-04"])
     }
 
-    @Test(.tags(.key))
-    func `[key] numeric 05`() throws {
+    @Test("[key] numeric 05", .tags(.key))
+    func key__numeric_05() throws {
         try verifyByFixture(pathComponents: ["key", "numeric-05"])
     }
 
-    @Test(.tags(.key))
-    func `[key] numeric 06`() throws {
+    @Test("[key] numeric 06", .tags(.key))
+    func key__numeric_06() throws {
         try verifyByFixture(pathComponents: ["key", "numeric-06"])
     }
 
-    @Test(.tags(.key))
-    func `[key] numeric 07`() throws {
+    @Test("[key] numeric 07", .tags(.key))
+    func key__numeric_07() throws {
         try verifyByFixture(pathComponents: ["key", "numeric-07"])
     }
 
-    @Test(.tags(.key))
-    func `[key] numeric 08`() throws {
+    @Test("[key] numeric 08", .tags(.key))
+    func key__numeric_08() throws {
         try verifyByFixture(pathComponents: ["key", "numeric-08"])
     }
 
-    @Test(.tags(.key))
-    func `[key] quoted dots`() throws {
+    @Test("[key] quoted dots", .tags(.key))
+    func key__quoted_dots() throws {
         try verifyByFixture(pathComponents: ["key", "quoted-dots"])
     }
 
-    @Test(.tags(.key))
-    func `[key] quoted unicode`() throws {
+    @Test("[key] quoted unicode", .tags(.key))
+    func key__quoted_unicode() throws {
         try verifyByFixture(pathComponents: ["key", "quoted-unicode"])
     }
 
-    @Test(.tags(.key))
-    func `[key] space`() throws {
+    @Test("[key] space", .tags(.key))
+    func key__space() throws {
         try verifyByFixture(pathComponents: ["key", "space"])
     }
 
-    @Test(.tags(.key))
-    func `[key] special chars`() throws {
+    @Test("[key] special chars", .tags(.key))
+    func key__special_chars() throws {
         try verifyByFixture(pathComponents: ["key", "special-chars"])
     }
 
-    @Test(.tags(.key))
-    func `[key] special word`() throws {
+    @Test("[key] special word", .tags(.key))
+    func key__special_word() throws {
         try verifyByFixture(pathComponents: ["key", "special-word"])
     }
 
-    @Test(.tags(.key))
-    func `[key] start`() throws {
+    @Test("[key] start", .tags(.key))
+    func key__start() throws {
         try verifyByFixture(pathComponents: ["key", "start"])
     }
 
-    @Test(.tags(.key))
-    func `[key] zero`() throws {
+    @Test("[key] zero", .tags(.key))
+    func key__zero() throws {
         try verifyByFixture(pathComponents: ["key", "zero"])
     }
 
-    @Test
+    @Test("multibyte")
     func multibyte() throws {
         try verifyByFixture(pathComponents: ["multibyte"])
     }
 
-    @Test
-    func `newline crlf`() throws {
+    @Test("newline crlf")
+    func newline_crlf() throws {
         try verifyByFixture(pathComponents: ["newline-crlf"])
     }
 
-    @Test
-    func `newline lf`() throws {
+    @Test("newline lf")
+    func newline_lf() throws {
         try verifyByFixture(pathComponents: ["newline-lf"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 0`() throws {
+    @Test("[spec-1.1.0] common 0", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_0() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-0"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 1`() throws {
+    @Test("[spec-1.1.0] common 1", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_1() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-1"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 10`() throws {
+    @Test("[spec-1.1.0] common 10", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_10() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-10"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 11`() throws {
+    @Test("[spec-1.1.0] common 11", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_11() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-11"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 12`() throws {
+    @Test("[spec-1.1.0] common 12", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_12() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-12"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 13`() throws {
+    @Test("[spec-1.1.0] common 13", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_13() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-13"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 14`() throws {
+    @Test("[spec-1.1.0] common 14", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_14() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-14"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 15`() throws {
+    @Test("[spec-1.1.0] common 15", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_15() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-15"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 16`() throws {
+    @Test("[spec-1.1.0] common 16", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_16() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-16"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 17`() throws {
+    @Test("[spec-1.1.0] common 17", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_17() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-17"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 18`() throws {
+    @Test("[spec-1.1.0] common 18", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_18() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-18"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 19`() throws {
+    @Test("[spec-1.1.0] common 19", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_19() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-19"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 20`() throws {
+    @Test("[spec-1.1.0] common 20", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_20() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-20"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 21`() throws {
+    @Test("[spec-1.1.0] common 21", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_21() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-21"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 22`() throws {
+    @Test("[spec-1.1.0] common 22", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_22() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-22"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 23`() throws {
+    @Test("[spec-1.1.0] common 23", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_23() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-23"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 24`() throws {
+    @Test("[spec-1.1.0] common 24", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_24() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-24"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 25`() throws {
+    @Test("[spec-1.1.0] common 25", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_25() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-25"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 26`() throws {
+    @Test("[spec-1.1.0] common 26", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_26() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-26"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 27`() throws {
+    @Test("[spec-1.1.0] common 27", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_27() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-27"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 28`() throws {
+    @Test("[spec-1.1.0] common 28", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_28() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-28"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 29`() throws {
+    @Test("[spec-1.1.0] common 29", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_29() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-29"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 3`() throws {
+    @Test("[spec-1.1.0] common 3", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_3() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-3"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 30`() throws {
+    @Test("[spec-1.1.0] common 30", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_30() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-30"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 31`() throws {
+    @Test("[spec-1.1.0] common 31", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_31() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-31"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 32`() throws {
+    @Test("[spec-1.1.0] common 32", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_32() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-32"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 33`() throws {
+    @Test("[spec-1.1.0] common 33", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_33() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-33"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 34`() throws {
+    @Test("[spec-1.1.0] common 34", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_34() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-34"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 35`() throws {
+    @Test("[spec-1.1.0] common 35", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_35() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-35"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 36`() throws {
+    @Test("[spec-1.1.0] common 36", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_36() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-36"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 37`() throws {
+    @Test("[spec-1.1.0] common 37", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_37() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-37"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 38`() throws {
+    @Test("[spec-1.1.0] common 38", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_38() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-38"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 39`() throws {
+    @Test("[spec-1.1.0] common 39", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_39() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-39"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 4`() throws {
+    @Test("[spec-1.1.0] common 4", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_4() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-4"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 40`() throws {
+    @Test("[spec-1.1.0] common 40", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_40() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-40"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 41`() throws {
+    @Test("[spec-1.1.0] common 41", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_41() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-41"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 42`() throws {
+    @Test("[spec-1.1.0] common 42", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_42() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-42"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 43`() throws {
+    @Test("[spec-1.1.0] common 43", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_43() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-43"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 44`() throws {
+    @Test("[spec-1.1.0] common 44", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_44() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-44"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 45`() throws {
+    @Test("[spec-1.1.0] common 45", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_45() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-45"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 46`() throws {
+    @Test("[spec-1.1.0] common 46", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_46() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-46"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 47`() throws {
+    @Test("[spec-1.1.0] common 47", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_47() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-47"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 48`() throws {
+    @Test("[spec-1.1.0] common 48", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_48() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-48"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 49`() throws {
+    @Test("[spec-1.1.0] common 49", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_49() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-49"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 50`() throws {
+    @Test("[spec-1.1.0] common 50", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_50() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-50"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 51`() throws {
+    @Test("[spec-1.1.0] common 51", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_51() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-51"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 52`() throws {
+    @Test("[spec-1.1.0] common 52", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_52() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-52"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 53`() throws {
+    @Test("[spec-1.1.0] common 53", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_53() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-53"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 6`() throws {
+    @Test("[spec-1.1.0] common 6", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_6() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-6"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 7`() throws {
+    @Test("[spec-1.1.0] common 7", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_7() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-7"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 8`() throws {
+    @Test("[spec-1.1.0] common 8", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_8() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-8"])
     }
 
-    @Test(.tags(.spec_1_1_0))
-    func `[spec-1.1.0] common 9`() throws {
+    @Test("[spec-1.1.0] common 9", .tags(.spec_1_1_0))
+    func spec_1_1_0__common_9() throws {
         try verifyByFixture(pathComponents: ["spec-1.1.0", "common-9"])
     }
 
-    @Test
-    func `spec example 1`() throws {
+    @Test("spec example 1")
+    func spec_example_1() throws {
         try verifyByFixture(pathComponents: ["spec-example-1"])
     }
 
-    @Test
-    func `spec example 1 compact`() throws {
+    @Test("spec example 1 compact")
+    func spec_example_1_compact() throws {
         try verifyByFixture(pathComponents: ["spec-example-1-compact"])
     }
 
-    @Test(.tags(.string))
-    func `[string] basic escape 01`() throws {
+    @Test("[string] basic escape 01", .tags(.string))
+    func string__basic_escape_01() throws {
         try verifyByFixture(pathComponents: ["string", "basic-escape-01"])
     }
 
-    @Test(.tags(.string))
-    func `[string] basic escape 02`() throws {
+    @Test("[string] basic escape 02", .tags(.string))
+    func string__basic_escape_02() throws {
         try verifyByFixture(pathComponents: ["string", "basic-escape-02"])
     }
 
-    @Test(.tags(.string))
-    func `[string] basic escape 03`() throws {
+    @Test("[string] basic escape 03", .tags(.string))
+    func string__basic_escape_03() throws {
         try verifyByFixture(pathComponents: ["string", "basic-escape-03"])
     }
 
-    @Test(.tags(.string))
-    func `[string] empty`() throws {
+    @Test("[string] empty", .tags(.string))
+    func string__empty() throws {
         try verifyByFixture(pathComponents: ["string", "empty"])
     }
 
-    @Test(.tags(.string))
-    func `[string] ends in whitespace escape`() throws {
+    @Test("[string] ends in whitespace escape", .tags(.string))
+    func string__ends_in_whitespace_escape() throws {
         try verifyByFixture(pathComponents: ["string", "ends-in-whitespace-escape"])
     }
 
-    @Test(.tags(.string))
-    func `[string] escape esc`() throws {
+    @Test("[string] escape esc", .tags(.string))
+    func string__escape_esc() throws {
         try verifyByFixture(pathComponents: ["string", "escape-esc"])
     }
 
-    @Test(.tags(.string))
-    func `[string] escape tricky`() throws {
+    @Test("[string] escape tricky", .tags(.string))
+    func string__escape_tricky() throws {
         try verifyByFixture(pathComponents: ["string", "escape-tricky"])
     }
 
-    @Test(.tags(.string))
-    func `[string] escaped escape`() throws {
+    @Test("[string] escaped escape", .tags(.string))
+    func string__escaped_escape() throws {
         try verifyByFixture(pathComponents: ["string", "escaped-escape"])
     }
 
-    @Test(.tags(.string))
-    func `[string] escapes`() throws {
+    @Test("[string] escapes", .tags(.string))
+    func string__escapes() throws {
         try verifyByFixture(pathComponents: ["string", "escapes"])
     }
 
-    @Test(.tags(.string))
-    func `[string] hex escape`() throws {
+    @Test("[string] hex escape", .tags(.string))
+    func string__hex_escape() throws {
         try verifyByFixture(pathComponents: ["string", "hex-escape"])
     }
 
-    @Test(.tags(.string))
-    func `[string] multibyte`() throws {
+    @Test("[string] multibyte", .tags(.string))
+    func string__multibyte() throws {
         try verifyByFixture(pathComponents: ["string", "multibyte"])
     }
 
-    @Test(.tags(.string))
-    func `[string] multibyte escape`() throws {
+    @Test("[string] multibyte escape", .tags(.string))
+    func string__multibyte_escape() throws {
         try verifyByFixture(pathComponents: ["string", "multibyte-escape"])
     }
 
-    @Test(.tags(.string))
-    func `[string] multiline`() throws {
+    @Test("[string] multiline", .tags(.string))
+    func string__multiline() throws {
         try verifyByFixture(pathComponents: ["string", "multiline"])
     }
 
-    @Test(.tags(.string))
-    func `[string] multiline empty`() throws {
+    @Test("[string] multiline empty", .tags(.string))
+    func string__multiline_empty() throws {
         try verifyByFixture(pathComponents: ["string", "multiline-empty"])
     }
 
-    @Test(.tags(.string))
-    func `[string] multiline escaped crlf`() throws {
+    @Test("[string] multiline escaped crlf", .tags(.string))
+    func string__multiline_escaped_crlf() throws {
         try verifyByFixture(pathComponents: ["string", "multiline-escaped-crlf"])
     }
 
-    @Test(.tags(.string))
-    func `[string] multiline quotes`() throws {
+    @Test("[string] multiline quotes", .tags(.string))
+    func string__multiline_quotes() throws {
         try verifyByFixture(pathComponents: ["string", "multiline-quotes"])
     }
 
-    @Test(.tags(.string))
-    func `[string] nl`() throws {
+    @Test("[string] nl", .tags(.string))
+    func string__nl() throws {
         try verifyByFixture(pathComponents: ["string", "nl"])
     }
 
-    @Test(.tags(.string))
-    func `[string] quoted unicode`() throws {
+    @Test("[string] quoted unicode", .tags(.string))
+    func string__quoted_unicode() throws {
         try verifyByFixture(pathComponents: ["string", "quoted-unicode"])
     }
 
-    @Test(.tags(.string))
-    func `[string] raw`() throws {
+    @Test("[string] raw", .tags(.string))
+    func string__raw() throws {
         try verifyByFixture(pathComponents: ["string", "raw"])
     }
 
-    @Test(.tags(.string))
-    func `[string] raw empty`() throws {
+    @Test("[string] raw empty", .tags(.string))
+    func string__raw_empty() throws {
         try verifyByFixture(pathComponents: ["string", "raw-empty"])
     }
 
-    @Test(.tags(.string))
-    func `[string] raw multiline`() throws {
+    @Test("[string] raw multiline", .tags(.string))
+    func string__raw_multiline() throws {
         try verifyByFixture(pathComponents: ["string", "raw-multiline"])
     }
 
-    @Test(.tags(.string))
-    func `[string] simple`() throws {
+    @Test("[string] simple", .tags(.string))
+    func string__simple() throws {
         try verifyByFixture(pathComponents: ["string", "simple"])
     }
 
-    @Test(.tags(.string))
-    func `[string] start mb`() throws {
+    @Test("[string] start mb", .tags(.string))
+    func string__start_mb() throws {
         try verifyByFixture(pathComponents: ["string", "start-mb"])
     }
 
-    @Test(.tags(.string))
-    func `[string] unicode escape`() throws {
+    @Test("[string] unicode escape", .tags(.string))
+    func string__unicode_escape() throws {
         try verifyByFixture(pathComponents: ["string", "unicode-escape"])
     }
 
-    @Test(.tags(.string))
-    func `[string] with pound`() throws {
+    @Test("[string] with pound", .tags(.string))
+    func string__with_pound() throws {
         try verifyByFixture(pathComponents: ["string", "with-pound"])
     }
 
-    @Test(.tags(.table))
-    func `[table] array empty`() throws {
+    @Test("[table] array empty", .tags(.table))
+    func table__array_empty() throws {
         try verifyByFixture(pathComponents: ["table", "array-empty"])
     }
 
-    @Test(.tags(.table))
-    func `[table] array empty name`() throws {
+    @Test("[table] array empty name", .tags(.table))
+    func table__array_empty_name() throws {
         try verifyByFixture(pathComponents: ["table", "array-empty-name"])
     }
 
-    @Test(.tags(.table))
-    func `[table] array implicit`() throws {
+    @Test("[table] array implicit", .tags(.table))
+    func table__array_implicit() throws {
         try verifyByFixture(pathComponents: ["table", "array-implicit"])
     }
 
-    @Test(.tags(.table))
-    func `[table] array implicit and explicit after`() throws {
+    @Test("[table] array implicit and explicit after", .tags(.table))
+    func table__array_implicit_and_explicit_after() throws {
         try verifyByFixture(pathComponents: ["table", "array-implicit-and-explicit-after"])
     }
 
-    @Test(.tags(.table))
-    func `[table] array many`() throws {
+    @Test("[table] array many", .tags(.table))
+    func table__array_many() throws {
         try verifyByFixture(pathComponents: ["table", "array-many"])
     }
 
-    @Test(.tags(.table))
-    func `[table] array nest`() throws {
+    @Test("[table] array nest", .tags(.table))
+    func table__array_nest() throws {
         try verifyByFixture(pathComponents: ["table", "array-nest"])
     }
 
-    @Test(.tags(.table))
-    func `[table] array one`() throws {
+    @Test("[table] array one", .tags(.table))
+    func table__array_one() throws {
         try verifyByFixture(pathComponents: ["table", "array-one"])
     }
 
-    @Test(.tags(.table))
-    func `[table] array table array`() throws {
+    @Test("[table] array table array", .tags(.table))
+    func table__array_table_array() throws {
         try verifyByFixture(pathComponents: ["table", "array-table-array"])
     }
 
-    @Test(.tags(.table))
-    func `[table] array within dotted`() throws {
+    @Test("[table] array within dotted", .tags(.table))
+    func table__array_within_dotted() throws {
         try verifyByFixture(pathComponents: ["table", "array-within-dotted"])
     }
 
-    @Test(.tags(.table))
-    func `[table] empty`() throws {
+    @Test("[table] empty", .tags(.table))
+    func table__empty() throws {
         try verifyByFixture(pathComponents: ["table", "empty"])
     }
 
-    @Test(.tags(.table))
-    func `[table] empty name`() throws {
+    @Test("[table] empty name", .tags(.table))
+    func table__empty_name() throws {
         try verifyByFixture(pathComponents: ["table", "empty-name"])
     }
 
-    @Test(.tags(.table))
-    func `[table] keyword`() throws {
+    @Test("[table] keyword", .tags(.table))
+    func table__keyword() throws {
         try verifyByFixture(pathComponents: ["table", "keyword"])
     }
 
-    @Test(.tags(.table))
-    func `[table] keyword with values`() throws {
+    @Test("[table] keyword with values", .tags(.table))
+    func table__keyword_with_values() throws {
         try verifyByFixture(pathComponents: ["table", "keyword-with-values"])
     }
 
-    @Test(.tags(.table))
-    func `[table] names`() throws {
+    @Test("[table] names", .tags(.table))
+    func table__names() throws {
         try verifyByFixture(pathComponents: ["table", "names"])
     }
 
-    @Test(.tags(.table))
-    func `[table] names with values`() throws {
+    @Test("[table] names with values", .tags(.table))
+    func table__names_with_values() throws {
         try verifyByFixture(pathComponents: ["table", "names-with-values"])
     }
 
-    @Test(.tags(.table))
-    func `[table] no eol`() throws {
+    @Test("[table] no eol", .tags(.table))
+    func table__no_eol() throws {
         try verifyByFixture(pathComponents: ["table", "no-eol"])
     }
 
-    @Test(.tags(.table))
-    func `[table] sub`() throws {
+    @Test("[table] sub", .tags(.table))
+    func table__sub() throws {
         try verifyByFixture(pathComponents: ["table", "sub"])
     }
 
-    @Test(.tags(.table))
-    func `[table] sub empty`() throws {
+    @Test("[table] sub empty", .tags(.table))
+    func table__sub_empty() throws {
         try verifyByFixture(pathComponents: ["table", "sub-empty"])
     }
 
-    @Test(.tags(.table))
-    func `[table] whitespace`() throws {
+    @Test("[table] whitespace", .tags(.table))
+    func table__whitespace() throws {
         try verifyByFixture(pathComponents: ["table", "whitespace"])
     }
 
-    @Test(.tags(.table))
-    func `[table] with literal string`() throws {
+    @Test("[table] with literal string", .tags(.table))
+    func table__with_literal_string() throws {
         try verifyByFixture(pathComponents: ["table", "with-literal-string"])
     }
 
-    @Test(.tags(.table))
-    func `[table] with pound`() throws {
+    @Test("[table] with pound", .tags(.table))
+    func table__with_pound() throws {
         try verifyByFixture(pathComponents: ["table", "with-pound"])
     }
 
-    @Test(.tags(.table))
-    func `[table] with single quotes`() throws {
+    @Test("[table] with single quotes", .tags(.table))
+    func table__with_single_quotes() throws {
         try verifyByFixture(pathComponents: ["table", "with-single-quotes"])
     }
 
-    @Test(.tags(.table))
-    func `[table] without super`() throws {
+    @Test("[table] without super", .tags(.table))
+    func table__without_super() throws {
         try verifyByFixture(pathComponents: ["table", "without-super"])
     }
 
-    @Test(.tags(.table))
-    func `[table] without super with values`() throws {
+    @Test("[table] without super with values", .tags(.table))
+    func table__without_super_with_values() throws {
         try verifyByFixture(pathComponents: ["table", "without-super-with-values"])
     }
 }

From 746c7f48f5207726a1fb9bf302c3ae63ad444834 Mon Sep 17 00:00:00 2001
From: Daniel Duan <daniel@duan.ca>
Date: Thu, 9 Jul 2026 01:44:15 -0700
Subject: [PATCH 4/4] Configure pinned SwiftFormat

---
 .swiftformat | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.swiftformat b/.swiftformat
index 269b5b50..daa5aed0 100644
--- a/.swiftformat
+++ b/.swiftformat
@@ -1,4 +1,7 @@
 --disable redundantBackticks
+--disable redundantSwiftTestingSuite
+--disable swiftTestingTestCaseNames
+--disable wrapIfStatementBodies
 --extension-acl on-declarations
 --ifdef no-indent
 --trailing-commas collections-only