Remove outdating parsing tests

Author: carson-katri

Package.swift

@@ -162,13 +162,6 @@ let package = Package(
             name: "LiveViewNativeStylesheetTests",
             dependencies: ["LiveViewNativeStylesheet", "LiveViewNative"]
         ),
-        .testTarget(
-            name: "LiveViewNativeStylesheetMacrosTests",
-            dependencies: [
-                "LiveViewNativeStylesheetMacros",
-                .product(name: "SwiftSyntaxMacrosTestSupport", package: "swift-syntax"),
-            ]
-        ),
 
         // Helpers
         .target(

Tests/LiveViewNativeStylesheetMacrosTests/MacroTests.swift

@@ -12,54 +12,19 @@ import SwiftUI
 final class ExternalTests: XCTestCase {
     func testASTNode() throws {
         XCTAssertEqual(
-            try ASTNode("node") {
-                StringLiteral()
-            }
-                .parse(#"{:node, [], "Hello, world!"}"#)
-                .value,
-            "Hello, world!"
+            try JSONDecoder().decode(ASTNode.self, from: Data(#"["node", {}, ["Hello, world!"]]"#.utf8)),
+            ASTNode(identifier: "node", annotations: .init(), arguments: [.unlabeled(.string("Hello, world!"))])
         )
     }
 
-    func testChainedMemberExpression() throws {
-        let value = try ChainedMemberExpression {
-            AtomLiteral()
-        } member: {
-            AtomLiteral()
-        }
-            .parse(#"{:., [], [nil, {:., [], [:a, :b]}]}"#)
-        XCTAssertEqual(value.base, "a")
-        XCTAssertEqual(value.members, ["b"])
-    }
-    
-    func testImplicitStaticMember() throws {
-        let parser = ImplicitStaticMember([
-            "a": "A",
-            "b": "B",
-            "c": "C"
-        ])
-        XCTAssertEqual(try parser.parse("{:., [], [nil, :a]}"), "A")
-        XCTAssertEqual(try parser.parse("{:., [], [nil, :b]}"), "B")
-        XCTAssertEqual(try parser.parse("{:., [], [nil, :c]}"), "C")
-    }
-    
-    func testMemberExpression() throws {
-        let value = try MemberExpression {
-            AtomLiteral()
-        } member: {
-            AtomLiteral()
-        }.parse("{:., [], [:a, :b]}")
-        XCTAssertEqual(value.base, "a")
-        XCTAssertEqual(value.member, "b")
-    }
-    
-    func testMetadata() throws {
-        XCTAssertEqual(try Metadata.parser().parse("[]"), Metadata(file: "", line: 0, module: "", source: ""))
+    func testAnnotations() throws {
+        XCTAssertEqual(
+            try JSONDecoder().decode(Annotations.self, from: Data("{}".utf8)),
+            Annotations()
+        )
         XCTAssertEqual(
-            try Metadata.parser().parse(
-                #"[file: "test.ex", line: 5, module: MyApp.Module, source: "source code"]"#
-            ),
-            Metadata(file: "test.ex", line: 5, module: "MyApp.Module", source: "source code")
+            try JSONDecoder().decode(Annotations.self, from: Data(#"{ "file": "file", "line": 1, "module": "module", "source": "source" }"#.utf8)),
+            Annotations(file: "file", line: 1, module: "module", source: "source")
         )
     }
 }

Tests/LiveViewNativeStylesheetTests/ExternalTests.swift

@@ -11,32 +11,13 @@ import SwiftUI
 
 final class LiteralTests: XCTestCase {
     func testAtomLiteral() throws {
-        XCTAssertEqual(try AtomLiteral().parse(":value"), "value")
-        XCTAssertEqual(try AtomLiteral().parse(#":"my-value""#), "my-value")
-    }
-    
-    func testListLiteral() throws {
-        XCTAssertEqual(try ListLiteral { StringLiteral() }.parse(#"["a", "b"]"#), ["a", "b"])
-        XCTAssertEqual(try ListLiteral { AtomLiteral() }.parse("[:a, :b]"), ["a", "b"])
         XCTAssertEqual(
-            try ListLiteral {
-                ListLiteral {
-                    StringLiteral()
-                }
-            }.parse(#"[["a", "b"], ["c"]]"#),
-            [["a", "b"], ["c"]]
+            try JSONDecoder().decode(AtomLiteral.self, from: Data(#"[":", {}, "value"]"#.utf8)).value,
+            AtomLiteral("value").value
+        )
+        XCTAssertEqual(
+            try JSONDecoder().decode(AtomLiteral.self, from: Data(#"[":", {}, "my-value"]"#.utf8)).value,
+            AtomLiteral("my-value").value
         )
-    }
-    
-    func testNilLiteral() throws {
-        XCTAssertNoThrow(try NilLiteral().parse("nil"))
-        XCTAssertThrowsError(try NilLiteral().parse("null"))
-    }
-    
-    func testStringLiteral() throws {
-        XCTAssertEqual(try StringLiteral().parse(#""Hello, world!""#), "Hello, world!")
-        XCTAssertEqual(try StringLiteral().parse(#""\"Hello, world!\"""#), "\"Hello, world!\"")
-        XCTAssertEqual(try StringLiteral().parse(#""\\n""#), "\\n")
-        XCTAssertEqual(try StringLiteral().parse(#""\/\b\f\n\r\t""#), "/\u{8}\u{c}\n\r\t")
     }
 }

Tests/LiveViewNativeStylesheetTests/LiteralTests.swift

@@ -5,23 +5,5 @@ import SwiftUI
 
 @MainActor
 final class LiveViewNativeStylesheetTests: XCTestCase {
-    func testAlignment() throws {
-        XCTAssertEqual(try Alignment.parser(in: .init()).parse("{:., [], [nil, :topLeading]}"), Alignment.topLeading)
-        XCTAssertEqual(try Alignment.parser(in: .init()).parse("{:., [], [nil, :top]}"), Alignment.top)
-        XCTAssertEqual(try Alignment.parser(in: .init()).parse("{:., [], [nil, :centerFirstTextBaseline]}"), Alignment.centerFirstTextBaseline)
-        XCTAssertEqual(try Alignment.parser(in: .init()).parse("{:., [], [nil, :centerLastTextBaseline]}"), Alignment.centerLastTextBaseline)
-        XCTAssertEqual(try Alignment.parser(in: .init()).parse("{:., [], [nil, :leadingFirstTextBaseline]}"), Alignment.leadingFirstTextBaseline)
-        XCTAssertEqual(try Alignment.parser(in: .init()).parse("{:., [], [nil, :leadingLastTextBaseline]}"), Alignment.leadingLastTextBaseline)
-        XCTAssertEqual(try Alignment.parser(in: .init()).parse("{:., [], [nil, :trailingFirstTextBaseline]}"), Alignment.trailingFirstTextBaseline)
-        XCTAssertEqual(try Alignment.parser(in: .init()).parse("{:., [], [nil, :trailingLastTextBaseline]}"), Alignment.trailingLastTextBaseline)
-        XCTAssertEqual(try Alignment.parser(in: .init()).parse("{:., [], [nil, :topLeading]}"), Alignment.topLeading)
-        XCTAssertEqual(try Alignment.parser(in: .init()).parse("{:., [], [nil, :topTrailing]}"), Alignment.topTrailing)
-        XCTAssertEqual(try Alignment.parser(in: .init()).parse("{:., [], [nil, :bottomLeading]}"), Alignment.bottomLeading)
-        XCTAssertEqual(try Alignment.parser(in: .init()).parse("{:., [], [nil, :bottomTrailing]}"), Alignment.bottomTrailing)
-        XCTAssertEqual(try Alignment.parser(in: .init()).parse("{:., [], [nil, :top]}"), Alignment.top)
-        XCTAssertEqual(try Alignment.parser(in: .init()).parse("{:., [], [nil, :bottom]}"), Alignment.bottom)
-        XCTAssertEqual(try Alignment.parser(in: .init()).parse("{:., [], [nil, :center]}"), Alignment.center)
-        XCTAssertEqual(try Alignment.parser(in: .init()).parse("{:., [], [nil, :leading]}"), Alignment.leading)
-        XCTAssertEqual(try Alignment.parser(in: .init()).parse("{:., [], [nil, :trailing]}"), Alignment.trailing)
-    }
+    
 }