[Chunked] Minor adjustments on tests

Author: LucianoPAlmeida

Sources/Algorithms/Chunked.swift

@@ -368,12 +368,12 @@ where Base: RandomAccessCollection {
     guard limit != i else { return nil }
 
     if offset > 0 {
-      guard limit <= i || distance(from: i, to: limit) >= offset else {
+      guard limit < i || distance(from: i, to: limit) >= offset else {
         return nil
       }
       return offsetForward(i, offsetBy: offset)
     } else {
-      guard limit >= i || distance(from: i, to: limit) <= offset else {
+      guard limit > i || distance(from: i, to: limit) <= offset else {
         return nil
       }
       return offsetBackward(i, offsetBy: offset)
@@ -397,14 +397,14 @@ where Base: RandomAccessCollection {
   }
 
   @usableFromInline
-  internal func offsetBackward(_ i: Index, offsetBy n: Int) -> Index {
+  internal func offsetBackward(_ i: Index, offsetBy distance: Int) -> Index {
     var idx = i
-    var distance = n
+    var distance = distance
     // If we know that the last chunk is the only one that can possible
     // have a variadic count. So in order to simplify and avoid another
     // calculation of offsets(that is already done at `index(before:)`)
     // we just move one position already so the index can be calculated
-    // assuming all chunks have the same size.
+    // since all remaining chunks have the same size.
     if i.baseRange.lowerBound == base.endIndex {
       formIndex(before: &idx)
       distance += 1
@@ -420,7 +420,8 @@ where Base: RandomAccessCollection {
   }
 
   // Helper to compute index(offsetBy:) index.
-  internal func makeOffsetIndex(
+  @inline(__always)
+  private func makeOffsetIndex(
     from i: Index, baseBound: Base.Index, distance: Int
   ) -> Index {
     let baseStartIdx = base.index(

Tests/SwiftAlgorithmsTests/ChunkedTests.swift

@@ -85,28 +85,36 @@ final class ChunkedTests: XCTestCase {
     XCTAssertEqualSequences([Int]().chunks(ofCount: 1), [])
     XCTAssertEqualSequences([Int]().chunks(ofCount: 5), [])
 
-    let collection = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-    XCTAssertEqualSequences(collection.chunks(ofCount: 1),
+    let collection1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    XCTAssertEqualSequences(collection1.chunks(ofCount: 1),
                             [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]])
-    XCTAssertEqualSequences(collection.chunks(ofCount: 3),
+    XCTAssertEqualSequences(collection1.chunks(ofCount: 3),
                             [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]])
-    XCTAssertEqualSequences(collection.chunks(ofCount: 5),
+    XCTAssertEqualSequences(collection1.chunks(ofCount: 5),
                             [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
-    XCTAssertEqualSequences(collection.chunks(ofCount: 11),
+    XCTAssertEqualSequences(collection1.chunks(ofCount: 11),
                             [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]])
+    
+    let collection2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+    XCTAssertEqualSequences(collection2.chunks(ofCount: 3),
+                            [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11]])
   }
 
   func testChunksOfCountBidirectional() {
-    let collection = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    let collection1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
-    XCTAssertEqualSequences(collection.chunks(ofCount: 1).reversed(),
+    XCTAssertEqualSequences(collection1.chunks(ofCount: 1).reversed(),
                             [[10], [9], [8], [7], [6], [5], [4], [3], [2], [1]])
-    XCTAssertEqualSequences(collection.chunks(ofCount: 3).reversed(),
+    XCTAssertEqualSequences(collection1.chunks(ofCount: 3).reversed(),
                             [[10], [7, 8, 9], [4, 5, 6], [1, 2, 3]])
-    XCTAssertEqualSequences(collection.chunks(ofCount: 5).reversed(),
+    XCTAssertEqualSequences(collection1.chunks(ofCount: 5).reversed(),
                             [[6, 7, 8, 9, 10], [1, 2, 3, 4, 5]])
-    XCTAssertEqualSequences(collection.chunks(ofCount: 11).reversed(),
+    XCTAssertEqualSequences(collection1.chunks(ofCount: 11).reversed(),
                             [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]])
+    
+    let collection2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+    XCTAssertEqualSequences(collection2.chunks(ofCount: 3).reversed(),
+                            [[10, 11], [7, 8, 9], [4, 5, 6], [1, 2, 3]])
   }
 
   func testChunksOfCountCount() {
@@ -123,7 +131,7 @@ final class ChunkedTests: XCTestCase {
     XCTAssertEqual(collection2.chunks(ofCount: 9).count, 6)
   }
 
-  func testEmptyChunksTraversal() {
+  func testEmptyChunksOfCountTraversal() {
     let emptyChunks = [Int]().chunks(ofCount: 1)
 
     validateIndexTraversals(emptyChunks)
@@ -136,10 +144,17 @@ final class ChunkedTests: XCTestCase {
     validateIndexTraversals(chunks)
   }
 
-  func testChunksOfCountWithRemainderTraversal() {
+  func testChunksOfCountWithSingleRemainderTraversal() {
     let collection = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
     let chunks = collection.chunks(ofCount: 3)
 
     validateIndexTraversals(chunks)
   }
+  
+  func testChunksOfCountWithRemainder() {
+    let collection2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+    let chunks = collection2.chunks(ofCount: 3)
+    
+    validateIndexTraversals(chunks)
+  }
 }