port MarkdownPluginSwiftTests to Swift Testing

Author: tayloraswift

Package.swift

@@ -645,11 +645,10 @@ let package:Package = .init(
                 .product(name: "Testing_", package: "swift-grammar"),
             ]),
 
-        .executableTarget(name: "MarkdownPluginSwiftTests",
+        .testTarget(name: "MarkdownPluginSwiftTests",
             dependencies: [
                 .target(name: "MarkdownPluginSwift"),
                 .target(name: "MarkdownRendering"),
-                .product(name: "Testing_", package: "swift-grammar"),
             ]),
 
         .executableTarget(name: "MarkdownRenderingTests",

Sources/MarkdownPluginSwiftTests/Diffs.swift

@@ -0,0 +1,48 @@
+import HTML
+import MarkdownPluginSwift
+import MarkdownRendering
+import Testing
+
+@Suite
+struct Diffs
+{
+    @Test
+    static func Overlays()
+    {
+        let swift:Markdown.SwiftLanguage = .swift
+        let code:String = """
+        {
+            return \"""
+            Barbieland
+            One
+            Great
+            Free
+            \"""
+        }
+        """
+
+        let bytes:[UInt8] = .init(code.utf8)
+        let lines:[ArraySlice<UInt8>] = bytes.split(separator: 0x0A,
+            omittingEmptySubsequences: false)
+
+        let layered:Markdown.Bytecode = swift.parse(code: bytes,
+            diff: [
+                (bytes.startIndex ..< lines[3].startIndex, nil),
+                (lines[3].startIndex ..< lines[6].startIndex, .insert),
+                (lines[6].startIndex ..< bytes.endIndex, nil)
+            ])
+
+        let html:HTML = .init { $0 += layered.safe }
+
+        #expect("\(html)" == """
+            {
+                <span class='xk'>return</span> <span class='xs'>\"""</span>
+                <span class='xs'>Barbieland
+            </span><ins>    <span class='xs'>One
+            </span>    <span class='xs'>Great
+            </span>    <span class='xs'>Free</span>
+            </ins>    <span class='xs'>\"""</span>
+            }
+            """)
+    }
+}

Sources/MarkdownPluginSwiftTests/InterestingKeywords.swift

@@ -0,0 +1,98 @@
+import Signatures
+import Testing
+
+@_spi(testable)
+import MarkdownPluginSwift
+
+@Suite
+struct InterestingKeywords
+{
+    @Test
+    static func Actor()
+    {
+        let decl:String = "actor MargotRobbie"
+
+        var keywords:Signature<Never>.Expanded.InterestingKeywords = .init()
+        let expanded:Signature<Never>.Expanded = .init(decl,
+            keywords: &keywords)
+
+        #expect("\(expanded.bytecode.safe)" == decl)
+        #expect(keywords.actor)
+    }
+    @Test
+    static func Final()
+    {
+        let decl:String = "final class C"
+
+        var keywords:Signature<Never>.Expanded.InterestingKeywords = .init()
+        let expanded:Signature<Never>.Expanded = .init(decl,
+            keywords: &keywords)
+
+        #expect("\(expanded.bytecode.safe)" == decl)
+        #expect(keywords.final)
+    }
+    @Test
+    static func ClassSubscript()
+    {
+        let decl:String = "class subscript(index: Int) -> Int"
+
+        var keywords:Signature<Never>.Expanded.InterestingKeywords = .init()
+        let expanded:Signature<Never>.Expanded = .init(decl,
+            keywords: &keywords)
+
+        #expect("\(expanded.bytecode.safe)" == decl)
+        #expect(keywords.class)
+    }
+    @Test
+    static func ClassFunc()
+    {
+        let decl:String = "class func x() -> Int"
+
+        var keywords:Signature<Never>.Expanded.InterestingKeywords = .init()
+        let expanded:Signature<Never>.Expanded = .init(decl,
+            keywords: &keywords)
+
+        #expect("\(expanded.bytecode.safe)" == decl)
+        #expect(keywords.class)
+    }
+    @Test
+    static func ClassVar()
+    {
+        let decl:String = "class var x: Int { get }"
+
+        var keywords:Signature<Never>.Expanded.InterestingKeywords = .init()
+        let expanded:Signature<Never>.Expanded = .init(decl,
+            keywords: &keywords)
+
+        #expect("\(expanded.bytecode.safe)" == decl)
+        #expect(keywords.class)
+    }
+    @Test
+    static func FreestandingMacro()
+    {
+        let decl:String = """
+        @freestanding(expression) macro line<T: ExpressibleByIntegerLiteral>() -> T
+        """
+
+        var keywords:Signature<Never>.Expanded.InterestingKeywords = .init()
+        let expanded:Signature<Never>.Expanded = .init(decl,
+            keywords: &keywords)
+
+        #expect("\(expanded.bytecode.safe)" == decl)
+        #expect(keywords.freestanding)
+    }
+    @Test
+    static func AttachedMacro()
+    {
+        let decl:String = """
+        @attached(member) @attached(conformance) public macro OptionSet<RawType>()
+        """
+
+        var keywords:Signature<Never>.Expanded.InterestingKeywords = .init()
+        let expanded:Signature<Never>.Expanded = .init(decl,
+            keywords: &keywords)
+
+        #expect("\(expanded.bytecode.safe)" == decl)
+        #expect(keywords.attached)
+    }
+}