migrate SymbolGraphTests

Author: tayloraswift

Package.swift

@@ -672,10 +672,9 @@ let package:Package = .init(
                 .target(name: "Testing_"),
             ]),
 
-        .executableTarget(name: "SymbolGraphTests",
+        .testTarget(name: "SymbolGraphTests",
             dependencies: [
                 .target(name: "SymbolGraphs"),
-                .target(name: "Testing_"),
             ]),
 
         .executableTarget(name: "SymbolTests",
@@ -689,8 +688,7 @@ let package:Package = .init(
                 .target(name: "System_"),
                 .target(name: "Testing_"),
             ],
-            exclude:
-            [
+            exclude: [
                 "directories",
             ]),
 

Sources/SymbolGraphTests/Availabilities.swift

@@ -0,0 +1,54 @@
+import Availability
+import BSON
+import Testing
+
+@Suite
+enum Availabilities
+{
+    @Test
+    static func Basic() throws
+    {
+        let availability:Availability = .init(.init(
+            deprecated: .unconditionally,
+            renamed: "Renamed",
+            message: "Message"))
+
+        let bson:BSON.Document = .init(encoding: availability)
+        let decoded:Availability = try .init(bson: bson)
+
+        #expect(availability == decoded)
+    }
+    @Test
+    static func Agnostic() throws
+    {
+        let availability:Availability = .init(agnostic: [
+                .swift: .init(
+                    deprecated: .since(.minor(.v(5, 8))),
+                    renamed: "Renamed",
+                    message: "Message"),
+            ])
+
+        let bson:BSON.Document = .init(encoding: availability)
+        let decoded:Availability = try .init(bson: bson)
+
+        #expect(availability == decoded)
+    }
+    @Test
+    static func Platform() throws
+    {
+        let availability:Availability = .init(platforms: [
+                .macOS: .init(
+                    unavailable: .unconditionally,
+                    deprecated: .since(.patch(.v(0, 0, 0))),
+                    introduced: .patch(.v(5, 6, 7)),
+                    obsoleted: .minor(.v(8, 9)),
+                    renamed: "Renamed",
+                    message: "Message"),
+            ])
+
+        let bson:BSON.Document = .init(encoding: availability)
+        let decoded:Availability = try .init(bson: bson)
+
+        #expect(availability == decoded)
+    }
+}

Sources/SymbolGraphTests/Dependencies.swift

@@ -0,0 +1,24 @@
+import BSON
+import SymbolGraphs
+import Testing
+
+struct Dependencies
+{
+    @Test(arguments: [
+            .init(package: .init(name: "swift-example"),
+                requirement: .exact(.release(.v(1, 2, 3))),
+                revision: 0xabcd1234,
+                version: .stable(.release(.v(1, 2, 3)))),
+            .init(package: .init(name: "swift-example"),
+                requirement: nil,
+                revision: 0xabcd1234,
+                version: "master"),
+        ] as [SymbolGraphMetadata.Dependency])
+    static func Dependency(_ value:SymbolGraphMetadata.Dependency) throws
+    {
+        let encoded:BSON.Document = .init(encoding: value)
+        let decoded:SymbolGraphMetadata.Dependency = try .init(bson: encoded)
+
+        #expect(value == decoded)
+    }
+}

Sources/SymbolGraphTests/Generics.swift

@@ -0,0 +1,47 @@
+import BSON
+import Signatures
+import SymbolGraphs
+import Testing
+
+@Suite
+struct Generics
+{
+    @Test
+    static func Parameters() throws
+    {
+        let parameters:[GenericParameter] = [
+            .init(name: "T", depth: 0),
+            .init(name: "Element", depth: 0),
+            .init(name: "Element", depth: 1),
+            .init(name: "Element", depth: 12),
+            .init(name: "🇺🇸", depth: 1776),
+            .init(name: "🇺🇸", depth: .max),
+        ]
+
+        let bson:BSON.List = .init(elements: parameters)
+        let decoded:[GenericParameter] = try .init(bson: bson)
+
+        #expect(parameters == decoded)
+    }
+
+    @Test(arguments: [
+            .init(spelling: "", nominal: 13),
+            .init(spelling: "Dictionary<Int, String>.Index", nominal: nil),
+        ] as [GenericType<Int32>],
+        [
+            .conformer,
+            .subclass,
+            .equal
+        ] as [GenericOperator])
+    static func Constraints(_ whom:GenericType<Int32>, _ what:GenericOperator) throws
+    {
+        let constraint:GenericConstraint<Int32> = .where("T.RawValue",
+            is: what,
+            to: whom)
+
+        let bson:BSON.Document = .init(encoding: constraint)
+        let decoded:GenericConstraint<Int32> = try .init(bson: bson)
+
+        #expect(constraint == decoded)
+    }
+}