[tests] Adding equatable and hashble tests

Author: LucianoPAlmeida

Tests/SwiftAlgorithmsTests/CompactedTests.swift

@@ -19,19 +19,16 @@ final class CompactedTests: XCTestCase {
         .uniquePermutations(ofCount: 0...)
         .map(Array.init)
 
-  func testCompactedSequence() {
-    for array in self.tests {
-      let seq = AnySequence(array)
-      XCTAssertEqualSequences(seq.compactMap({ $0 }), seq.compacted())
-    }
-  }
-  
-  func testCompactedCollection() {
-    for array in self.tests {
-      XCTAssertEqualSequences(array.compactMap({ $0 }), array.compacted())
+  func testCompactedCompacted() {
+    for collection in self.tests {
+      let seq = AnySequence(collection)
+      XCTAssertEqualSequences(
+        seq.compactMap({ $0 }), seq.compacted())
+      XCTAssertEqualSequences(
+        collection.compactMap({ $0 }), collection.compacted())
     }
   }
-  
+
   func testCompactedBidirectionalCollection() {
     for array in self.tests {
       XCTAssertEqualSequences(array.compactMap({ $0 }).reversed(),
@@ -44,4 +41,28 @@ final class CompactedTests: XCTestCase {
       validateIndexTraversals(array)
     }
   }
+
+  func testCollectionEquatableConformances() {
+    for array in self.tests {
+      XCTAssertEqual(
+        array.eraseToAnyHashableSequence().compacted(),
+        array.compactMap({ $0 }).eraseToAnyHashableSequence().compacted()
+      )
+      XCTAssertEqual(
+        array.compacted(), array.compactMap({ $0 }).compacted()
+      )
+    }
+  }
+  
+  func testCollectionHashableConformances() {
+    for array in self.tests {
+      let seq = array.eraseToAnyHashableSequence()
+      XCTAssertEqualHashValue(
+        seq.compacted(), seq.compactMap({ $0 }).compacted()
+      )
+      XCTAssertEqualHashValue(
+        array.compacted(), array.compactMap({ $0 }).compacted()
+      )
+    }
+  }
 }

Tests/SwiftAlgorithmsTests/TestUtilities.swift

@@ -46,6 +46,26 @@ struct SplitMix64: RandomNumberGenerator {
   }
 }
 
+struct AnyHashableSequence<Base>
+  where Base: Sequence, Base: Hashable {
+  var base: Base
+}
+
+extension AnyHashableSequence: Hashable {}
+extension AnyHashableSequence: Sequence {
+  typealias Iterator = Base.Iterator
+  
+  func makeIterator() -> Iterator {
+    base.makeIterator()
+  }
+}
+
+extension Sequence where Self: Hashable {
+  func eraseToAnyHashableSequence() -> AnyHashableSequence<Self> {
+    AnyHashableSequence(base: self)
+  }
+}
+
 // An eraser helper to any mutable collection
 struct AnyMutableCollection<Base> where Base: MutableCollection {
   var base: Base
@@ -163,6 +183,25 @@ func XCTAssertEqualCollections<C1: Collection, C2: Collection>(
   }
 }
 
+func hash<T: Hashable>(_ value: T) -> Int {
+  var hasher = Hasher()
+  value.hash(into: &hasher)
+  return hasher.finalize()
+}
+
+/// Asserts two hashable value produce the same hash value.
+func XCTAssertEqualHashValue<T: Hashable, U: Hashable>(
+  _ expression1: @autoclosure () throws -> T,
+  _ expression2: @autoclosure () throws -> U,
+  _ message: @autoclosure () -> String = "",
+  file: StaticString = #file, line: UInt = #line
+) {
+  XCTAssertEqual(
+    hash(try expression1()), hash(try expression2()),
+    message(), file: file, line: line
+  )
+}
+
 /// Tests that all index traversal methods behave as expected.
 ///
 /// Verifies the correctness of the implementations of `startIndex`, `endIndex`,