[tests] [Compacted] Adding tests for compacted()

Author: LucianoPAlmeida

Tests/SwiftAlgorithmsTests/CompactedTests.swift

@@ -0,0 +1,68 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift Algorithms open source project
+//
+// Copyright (c) 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+//
+//===----------------------------------------------------------------------===//
+
+import XCTest
+import Algorithms
+
+final class CompactedTests: XCTestCase {
+
+  let tests: [[Int?]] =
+    [nil, nil, nil, 0, 1, 2]
+        .uniquePermutations(ofCount: 0...)
+        .map(Array.init)
+  
+  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(),
+                              array.compacted().reversed())
+    }
+  }
+  
+  func testCollectionTraversals() {
+    for array in self.tests {
+      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,27 @@ struct SplitMix64: RandomNumberGenerator {
   }
 }
 
+// An eraser helper to any hashable sequence.
+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 +184,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`,