Fix lazy sequence bug with separator count >= element count.

Because the array into which the lazy sequence iterator collected the subsequence
elements was a member property, it had to be manually emptied before each
invocation of `next`. Since there are multiple exit points from that method, there
were multiple places that had to be done, and of course I missed at least one. This
caused the last element of the base sequence to be repeated as necessary to make
`sequenceLength` equal `separatorCount + 1`, in the case where the number of
separators was equal to or great than the number of non-separators in the base
sequence, and the last sequence element was a non-separator.

Happily, it's not necessary for the subsequence array to be a member property of
the iterator, and making it a local fixes this bug, in addition to being the right and
proper thing to do.

Author: toddthomas

Sources/Algorithms/LazySplitSequence.swift

@@ -33,7 +33,6 @@ extension LazySplitSequence {
     internal let isSeparator: (Base.Element) -> Bool
     internal let maxSplits: Int
     internal let omittingEmptySubsequences: Bool
-    internal var subsequence: Element = []
     internal var separatorCount = 0
     internal var sequenceLength = 0
 
@@ -88,6 +87,7 @@ extension LazySplitSequence.Iterator: IteratorProtocol {
     ///     // last split  -> [], [], []
 
     var currentElement = base.next()
+    var subsequence: Element = []
 
     while currentElement != nil {
       if separatorCount < maxSplits && isSeparator(currentElement!) {

Tests/SwiftAlgorithmsTests/LazySplitCollectionTests.swift

@@ -195,4 +195,24 @@ final class LazySplitCollectionTests: XCTestCase {
     let testResult = empty.lazy.split(separator: 42)
     XCTAssertEqualSequences(expectedResult, testResult)
   }
+
+  func testSepCountEqualOrMoreThanElemCount() {
+    let nums = [0, 1, 0, 0, 2]
+    let expectedResult = nums.split(separator: 0)
+    let testResult = nums.lazy.split(separator: 0)
+    XCTAssertEqualSequences(testResult, expectedResult)
+  }
+
+  func testSepCountEqualOrMoreThanElemCountNotOmittingEmpty() {
+    let nums = [0, 1, 0, 0, 2]
+    let expectedResult = nums.split(
+      separator: 0,
+      omittingEmptySubsequences: false
+    )
+    let testResult = nums.lazy.split(
+      separator: 0,
+      omittingEmptySubsequences: false
+    )
+    XCTAssertEqualSequences(testResult, expectedResult)
+  }
 }

Tests/SwiftAlgorithmsTests/LazySplitSequenceTests.swift

@@ -82,4 +82,67 @@ final class LazySplitSequenceTests: XCTestCase {
     )
     XCTAssertEqualSequences(testResult, expectedResult)
   }
+
+  // Exercise the end-of-list logic to make sure we don't, for example, repeat
+  // the last element when there are an equal or greater number of separators
+  // than elements.
+  func testSepCountEqualElemCount() {
+    let nums = AnySequence([1, 0, 0, 2])
+    let expectedResult = nums.split(separator: 0).map { Array($0) }
+    let testResult = nums.lazy.split(separator: 0)
+    XCTAssertEqualSequences(testResult, expectedResult)
+  }
+
+  func testSepCountEqualElemCountNotOmittingEmpty() {
+    let nums = AnySequence([1, 0, 0, 2])
+    let expectedResult = nums.split(
+      separator: 0,
+      omittingEmptySubsequences: false
+    ).map { Array($0) }
+    let testResult = nums.lazy.split(
+      separator: 0,
+      omittingEmptySubsequences: false
+    )
+    XCTAssertEqualSequences(testResult, expectedResult)
+  }
+
+  func testSepCountMoreThanElemCountStartsWithSep() {
+    let nums = AnySequence([0, 1, 0, 0, 2])
+    let expectedResult = nums.split(separator: 0).map { Array($0) }
+    let testResult = nums.lazy.split(separator: 0)
+    XCTAssertEqualSequences(testResult, expectedResult)
+  }
+
+  func testSepCountMoreThanElemCountStartsWithSepNotOmittingEmpty() {
+    let nums = AnySequence([0, 1, 0, 0, 2])
+    let expectedResult = nums.split(
+      separator: 0,
+      omittingEmptySubsequences: false
+    ).map { Array($0) }
+    let testResult = nums.lazy.split(
+      separator: 0,
+      omittingEmptySubsequences: false
+    )
+    XCTAssertEqualSequences(testResult, expectedResult)
+  }
+
+  func testSepCountMoreThanElemCountStartsWithElem() {
+    let nums = AnySequence([1, 0, 0, 0, 0, 2, 0, 3])
+    let expectedResult = nums.split(separator: 0).map { Array($0) }
+    let testResult = nums.lazy.split(separator: 0)
+    XCTAssertEqualSequences(testResult, expectedResult)
+  }
+
+  func testSepCountMoreThanElemCountStartsWithElemNotOmittingEmpty() {
+    let nums = AnySequence([1, 0, 0, 0, 0, 2, 0, 3])
+    let expectedResult = nums.split(
+      separator: 0,
+      omittingEmptySubsequences: false
+    ).map { Array($0) }
+    let testResult = nums.lazy.split(
+      separator: 0,
+      omittingEmptySubsequences: false
+    )
+    XCTAssertEqualSequences(testResult, expectedResult)
+  }
 }