fix tests

Author: David Ungar

Sources/SwiftDriver/IncrementalCompilation/DependencyKey.swift

@@ -105,6 +105,12 @@ public struct FingerprintedExternalDependency: Hashable, Equatable, ExternalDepe
   }
 }
 
+extension FingerprintedExternalDependency: CustomStringConvertible {
+  public var description: String {
+    "\(externalDependency) \(fingerprint.map {"fingerprint: \($0)"} ?? "no fingerprint")"
+  }
+}
+
 /// A `DependencyKey` carries all of the information necessary to uniquely
 /// identify a dependency node in the graph, and serves as a point of identity
 /// for the dependency graph's map from definitions to uses.

Tests/SwiftDriverTests/DependencyGraphSerializationTests.swift

@@ -66,12 +66,18 @@ class DependencyGraphSerializationTests: XCTestCase, ModuleDependencyGraphMocker
       deserializedNodes.insert($0)
     }
 
-    XCTAssertTrue(originalNodes == deserializedNodes,
-                  "Round trip failed! Symmetric difference - \(originalNodes.symmetricDifference(deserializedNodes))")
+    failIfUnequalAcrossGraphs( (name:     "originalNodes", originalNodes),
+                               (name: "deserializedNodes", deserializedNodes),
+                               whatFailed: "Round trip")
 
-    XCTAssertEqual(graph.nodeFinder.usesByDef, deserializedGraph.nodeFinder.usesByDef)
-    XCTAssertEqual(graph.fingerprintedExternalDependencies,
-                   deserializedGraph.fingerprintedExternalDependencies)
+    failIfUnequalAcrossGraphs( (name:     "original usesByDef",             graph.nodeFinder.usesByDef),
+                               (name: "deserialized usesByDef", deserializedGraph.nodeFinder.usesByDef),
+                               whatFailed: "Round trip",
+                               compareBy: {"\($0.0.description): \($0.1.map{$0.description}.sorted())"})
+
+    failIfUnequalAcrossGraphs( (name:     "original fingerprintedExternalDependencies",             graph.fingerprintedExternalDependencies),
+                               (name: "deserialized fingerprintedExternalDependencies", deserializedGraph.fingerprintedExternalDependencies),
+                               whatFailed: "Round trip")
   }
 
   func testRoundTripFixtures() throws {

Tests/SwiftDriverTests/Helpers/MockingIncrementalCompilation.swift

@@ -201,3 +201,41 @@ extension Driver {
     }
   }
 }
+
+// MARK: - Graph comparison
+/// Test for  equality across graphs and fail descriptively if needed.
+/// String interning is relative to the containing graph, so much pass in compare transformation.
+func failIfUnequalAcrossGraphs<LHS: Sequence, RHS: Sequence>(
+  _ lhs: (name: String, LHS),
+  _ rhs: (name: String, RHS),
+  whatFailed: String,
+  compareBy: (LHS.Element) -> String
+)
+where LHS.Element == RHS.Element
+{
+  func reportDescs(presentIn present: (name: String, descs: Set<String>),
+                 butAbsentIn  absent: (name: String, descs: Set<String>)
+  ) {
+    let delta = present.descs.subtracting(absent.descs)
+    guard delta.isEmpty else {
+      XCTFail("\(whatFailed) failed! Present in \(present.name) but absent in \(absent.name): \(delta.sorted())")
+      return
+    }
+  }
+
+  let lDescs = (name: lhs.name, descs: Set(lhs.1.map(compareBy)))
+  let rDescs = (name: rhs.name, descs: Set(rhs.1.map(compareBy)))
+
+  reportDescs(presentIn: lDescs, butAbsentIn: rDescs)
+  reportDescs(presentIn: rDescs, butAbsentIn: lDescs)
+}
+
+/// Shorthand for ``failIfUnequalAcrossGraphs(_:_:whatFailed:compareBy:)`` when elements are ``CustomStringConvertible``
+func failIfUnequalAcrossGraphs<LHS: Sequence, RHS: Sequence>(
+  _ lhs: (name: String, LHS),
+  _ rhs: (name: String, RHS),
+  whatFailed: String)
+where LHS.Element: CustomStringConvertible, LHS.Element == RHS.Element
+{
+  failIfUnequalAcrossGraphs(lhs, rhs, whatFailed: whatFailed) {$0.description}
+}