Fix and enable testing stdlib Collection instances.

Top-level entry points fully testing a collection instance:
check${Traversal}Collection

One level of recursion into all slices of the collection instance
O(n^2). (Not combinatorial).

Previously, checkCollection() did nothing. So much of the testing infrastructure was inactive. Now it runs all forward collection tests.

Fixes a bug in subscriptRangeTests.

The UnsafeRawBufferPointer and Data collection testing is disabled and
will be fixed in the following commit.

stdlib/private/StdlibCollectionUnittest/CheckCollectionInstance.swift.gyb

@@ -269,9 +269,57 @@ public func checkAdvancesAndDistances<Instances, Distances, BaseCollection>(
 %   ('Expected: Collection',  'Expected.Iterator.Element',  'Expected'),
 %   ('Element'             ,  'Element'                  ,  'Array<Element>')]:
 
+// Top-level check for Collection instances. Alias for checkForwardCollection.
+// Checks all slices: O(n^2).
+public func checkCollection<${genericParam}, C : Collection>(
+  _ expected: ${Expected},
+  _ collection: C,
+  ${TRACE},
+  resiliencyChecks: CollectionMisuseResiliencyChecks = .all,
+  sameValue: (${Element}, ${Element}) -> Bool
+) where C.Iterator.Element == ${Element},
+  // FIXME(ABI) (Associated Types with where clauses): these constraints should be applied to
+  // associated types of Collection.
+  C.Indices.Iterator.Element == C.Index,
+  C.SubSequence : Collection,
+  C.SubSequence.Iterator.Element == ${Element},
+  C.SubSequence.Indices.Iterator.Element == C.Index,
+  C.SubSequence.Index == C.Index {
+
+  checkForwardCollection(expected, collection, message(),
+    stackTrace: stackTrace, showFrame: showFrame, file: file, line: line,
+    resiliencyChecks: resiliencyChecks,
+    sameValue: sameValue)
+}
+
 %   for Traversal in TRAVERSALS:
 %     TraversalCollection = collectionForTraversal(Traversal)
 
+// Calls check${Traversal}Collection with default `sameValue`.
+public func check${Traversal}Collection<
+  ${genericParam}, C : ${TraversalCollection}
+>(
+  _ expected: ${Expected}, _ collection: C,
+  ${TRACE},
+  resiliencyChecks: CollectionMisuseResiliencyChecks = .all
+) where
+  C.Iterator.Element == ${Element},
+  C.Indices.Iterator.Element == C.Index,
+  C.SubSequence : ${TraversalCollection},
+  C.SubSequence.Iterator.Element == ${Element},
+  C.SubSequence.Indices.Iterator.Element == C.Index,
+  C.SubSequence.Index == C.Index,
+  ${Element} : Equatable {
+
+  check${Traversal}Collection(
+    expected, collection, ${trace},
+    resiliencyChecks: resiliencyChecks) { $0 == $1 }
+}
+
+// Top-Level check for all ${TraversalCollection} semantics on a single
+// instance. This constrains SubSequence associated types in order to check
+// slice semantics.
+// Checks all slices: O(n^2).
 public func check${Traversal}Collection<
   ${genericParam}, C : ${TraversalCollection}
 >(
@@ -281,6 +329,40 @@ public func check${Traversal}Collection<
   sameValue: (${Element}, ${Element}) -> Bool
 ) where
   C.Iterator.Element == ${Element},
+  // FIXME(ABI) (Associated Types with where clauses): these constraints should be applied to
+  // associated types of Collection.
+  C.Indices.Iterator.Element == C.Index,
+  C.SubSequence : ${TraversalCollection},
+  C.SubSequence.Iterator.Element == ${Element},
+  C.SubSequence.Index == C.Index,
+  C.SubSequence.Indices.Iterator.Element == C.Index {
+
+  _checkOneLevelOf${Traversal}Collection(expected, collection, ${trace},
+    resiliencyChecks: resiliencyChecks, sameValue: sameValue)
+
+  _checkSliceableWith${Traversal}Index(expected, collection, ${trace},
+    resiliencyChecks: resiliencyChecks, sameValue: sameValue)
+}
+
+// Helper for check${Traversal}Collection. Check that instance of `C`,
+// `collection`, upholds the semantics of `${TraversalCollection}`,
+// non-recursively. This does not check subsequences. It may be called for each
+// subsequence without combinatorial explosion. Also, since recursive protocol
+// contraints are not supported, our second level of checks cannot depend on the
+// associated type properties of SubSequence.
+//
+// Checks all slices: O(n^2).
+internal func _checkOneLevelOf${Traversal}Collection<
+  ${genericParam}, C : ${TraversalCollection}
+>(
+  _ expected: ${Expected}, _ collection: C,
+  ${TRACE},
+  resiliencyChecks: CollectionMisuseResiliencyChecks = .all,
+  sameValue: (${Element}, ${Element}) -> Bool
+) where
+  C.Iterator.Element == ${Element},
+  // FIXME(ABI) (Associated Types with where clauses): these constraints should be applied to
+  // associated types of Collection.
   C.Indices.Iterator.Element == C.Index {
 
   // A `Collection` is a multi-pass `Sequence`.
@@ -290,6 +372,10 @@ public func check${Traversal}Collection<
       resiliencyChecks: resiliencyChecks, sameValue: sameValue)
   }
 
+  //===------------------------------------------------------------------===//
+  // Check Index semantics
+  //===------------------------------------------------------------------===//
+
   let succ = { collection.index(after: $0) }
 %     if Traversal != 'Forward':
   let pred = { collection.index(before: $0) }
@@ -356,9 +442,14 @@ public func check${Traversal}Collection<
 
   let expectedArray = Array(expected)
 
+  // Check `count`.
   expectEqual(
     expectedArray.count.toIntMax(), collection.count.toIntMax(), ${trace})
 
+  //===------------------------------------------------------------------===//
+  // Check Iteration behavior.
+  //===------------------------------------------------------------------===//
+
   for _ in 0..<3 {
     do {
       let startIndex = collection.startIndex
@@ -414,7 +505,7 @@ public func check${Traversal}Collection<
           expectedArray[i], collection[index], ${trace}, sameValue: sameValue)
       }
 
-%       end
+%       end # Traversal == "Bidirectional"
 
     } // end of `if expectedArray.count >= 2`
 
@@ -440,65 +531,57 @@ public func check${Traversal}Collection<
   // FIXME: more checks for bidirectional and random access collections.
 }
 
-public func check${Traversal}Collection<
+// Helper for check${Traversal}Collection to check Slices.
-  ${genericParam}, C : ${TraversalCollection}
+//
+// Checks all slices: O(n^2).
+internal func _checkSliceableWith${Traversal}Index<
+${genericParam}, S : ${TraversalCollection}
 >(
-  _ expected: ${Expected}, _ collection: C,
+  _ expected: ${Expected}, _ sliceable: S, ${TRACE},
-  ${TRACE},
+  resiliencyChecks: CollectionMisuseResiliencyChecks = .all,
-  resiliencyChecks: CollectionMisuseResiliencyChecks = .all
+  sameValue: (${Element}, ${Element}) -> Bool
-) where
-  C.Iterator.Element == ${Element},
-  C.Indices.Iterator.Element == C.Index,
-  ${Element} : Equatable {
-
-  check${Traversal}Collection(
-    expected, collection, ${trace},
-    resiliencyChecks: resiliencyChecks) { $0 == $1 }
-}
-
-%   end
-
-// FIXME: merge into checkCollection()
-public func checkSliceableWithBidirectionalIndex<
-  ${genericParam}, S : BidirectionalCollection
->(
-  _ expected: ${Expected}, _ sliceable: S, ${TRACE}
 ) where
   S.Iterator.Element == ${Element},
-  S.Indices.Iterator.Element == S.Index,
+  S.SubSequence : ${TraversalCollection},
-  S.SubSequence : BidirectionalCollection,
   S.SubSequence.Iterator.Element == ${Element},
-  S.SubSequence.Indices.Iterator.Element == S.SubSequence.Index,
+  S.SubSequence.Index == S.Index,
-  ${Element} : Equatable {
+  S.SubSequence.Indices.Iterator.Element == S.Index {
-
-  // A `Sliceable` is a `Collection`.
-  checkBidirectionalCollection(expected, sliceable, ${trace})
 
   let expectedArray = Array(expected)
 
   let succ = { sliceable.index(after: $0) }
+%       if Traversal != "Forward":
   let pred = { sliceable.index(before: $0) }
+%       end
 
   var start = sliceable.startIndex
   for startNumericIndex in 0...expectedArray.count {
+%       if Traversal != "Forward":
     if start != sliceable.endIndex {
       start = succ(start)
       start = pred(start)
       start = succ(start)
       start = pred(start)
     }
+%       end
     var end = start
     for endNumericIndex in startNumericIndex...expectedArray.count {
+%       if Traversal != "Forward":
       if end != sliceable.endIndex {
         end = succ(end)
         end = pred(end)
         end = succ(end)
         end = pred(end)
       }
+%       end
       let expectedSlice = expectedArray[startNumericIndex..<endNumericIndex]
       let slice = sliceable[start..<end]
+      //FIXME!!!: expectEqual(start, slice.startIndex)
+      //FIXME!!!: expectEqual(end, slice.endIndex)
 
-      checkBidirectionalCollection(expectedSlice, slice, ${trace})
+      _checkOneLevelOf${Traversal}Collection(expectedSlice, slice, ${trace},
+        resiliencyChecks: resiliencyChecks,
+        sameValue: sameValue)
 
       if end != sliceable.endIndex {
         end = succ(end)
@@ -510,9 +593,13 @@ public func checkSliceableWithBidirectionalIndex<
   }
 }
 
-% end
+%   end # Traversal
 
+% end # genericParam, Elements, Expected
 
+// Check RangeReplaceableCollection using a factory.
+//
+// Note: This does not invoke other collection tests.
 public func checkRangeReplaceable<C, N>(
   _ makeCollection: @escaping () -> C,
   _ makeNewValues: (Int) -> N
@@ -574,13 +661,3 @@ public func checkRangeReplaceable<C, N>(
     }
   }
 }
-
-public func checkCollection<C : Collection, Expected : Collection>(
-  _ subject: C,
-  expected: Expected,
-  ${TRACE},
-  resiliencyChecks: CollectionMisuseResiliencyChecks = .all,
-  sameValue: (Expected.Iterator.Element, Expected.Iterator.Element) -> Bool
-) where C.Iterator.Element == Expected.Iterator.Element {
-}
-

stdlib/private/StdlibCollectionUnittest/CheckCollectionType.swift.gyb

@@ -120,85 +120,85 @@ public let subscriptRangeTests = [
 
   // Slice to the full extent.
   SubscriptRangeTest(
-    expected: [ 1010 ],
+    expected: [1010],
-    collection: [ 1010 ],
+    collection: [1010],
     bounds: 0..<1,
     count: 1),
   SubscriptRangeTest(
-    expected: [ 1010, 2020, 3030 ],
+    expected: [1010, 2020, 3030],
-    collection: [ 1010, 2020, 3030 ],
+    collection: [1010, 2020, 3030],
     bounds: 0..<3,
     count: 3),
   SubscriptRangeTest(
-    expected: [ 1010, 2020, 3030, 4040, 5050 ],
+    expected: [1010, 2020, 3030, 4040, 5050],
-    collection: [ 1010, 2020, 3030, 4040, 5050 ],
+    collection: [1010, 2020, 3030, 4040, 5050],
     bounds: 0..<5,
     count: 5),
 
   // Slice an empty prefix.
   SubscriptRangeTest(
     expected: [],
-    collection: [ 1010, 2020, 3030 ],
+    collection: [1010, 2020, 3030],
     bounds: 0..<0,
     count: 3),
 
   // Slice a prefix.
   SubscriptRangeTest(
-    expected: [ 1010, 2020 ],
+    expected: [1010, 2020],
-    collection: [ 1010, 2020, 3030 ],
+    collection: [1010, 2020, 3030],
     bounds: 0..<2,
     count: 3),
   SubscriptRangeTest(
-    expected: [ 1010, 2020 ],
+    expected: [1010, 2020],
-    collection: [ 1010, 2020, 3030, 4040, 5050 ],
+    collection: [1010, 2020, 3030, 4040, 5050],
     bounds: 0..<2,
     count: 5),
 
   // Slice an empty suffix.
   SubscriptRangeTest(
     expected: [],
-    collection: [ 1010, 2020, 3030 ],
+    collection: [1010, 2020, 3030],
     bounds: 3..<3,
     count: 3),
 
   // Slice a suffix.
   SubscriptRangeTest(
-    expected: [ 2020, 3030 ],
+    expected: [2020, 3030],
-    collection: [ 1010, 2020, 3030 ],
+    collection: [1010, 2020, 3030],
     bounds: 1..<3,
     count: 3),
   SubscriptRangeTest(
-    expected: [ 4040, 5050 ],
+    expected: [4040, 5050],
-    collection: [ 1010, 2020, 3030, 4040, 5050 ],
+    collection: [1010, 2020, 3030, 4040, 5050],
     bounds: 3..<5,
     count: 5),
 
   // Slice an empty range in the middle.
   SubscriptRangeTest(
     expected: [],
-    collection: [ 1010, 2020, 3030 ],
+    collection: [1010, 2020, 3030],
     bounds: 1..<1,
     count: 3),
   SubscriptRangeTest(
     expected: [],
-    collection: [ 1010, 2020, 3030 ],
+    collection: [1010, 2020, 3030],
     bounds: 2..<2,
     count: 3),
 
   // Slice the middle part.
   SubscriptRangeTest(
-    expected: [ 2020 ],
+    expected: [2020],
-    collection: [ 1010, 2020, 3030 ],
+    collection: [1010, 2020, 3030],
     bounds: 1..<2,
     count: 3),
   SubscriptRangeTest(
-    expected: [ 3030 ],
+    expected: [3030],
-    collection: [ 1010, 2020, 3030, 4040 ],
+    collection: [1010, 2020, 3030, 4040],
-    bounds: 3..<4,
+    bounds: 2..<3,
     count: 4),
   SubscriptRangeTest(
-    expected: [ 2020, 3030, 4040 ],
+    expected: [2020, 3030, 4040],
-    collection: [ 1010, 2020, 3030, 4040, 5050, 6060 ],
+    collection: [1010, 2020, 3030, 4040, 5050, 6060],
     bounds: 1..<4,
     count: 6),
 ]
@@ -690,8 +690,8 @@ extension TestSuite {
         // TODO: swift-3-indexing-model: uncomment the following.
         // FIXME: improve checkForwardCollection to check the SubSequence type.
         checkCollection(
-          slice,
           expected: test.expected.map(wrapValue),
+          slice,
           resiliencyChecks: .none) {
           extractValue($0).value == extractValue($1).value
         }

test/stdlib/Inputs/CommonArrayTests.gyb

@@ -87,7 +87,7 @@ ${Suite}.test("${ArrayType}/Sliceable/Enums") {
   do {
     let expected = [E.A, E.B, E.C, E.D]
     let sliceable = ${ArrayType}(expected)
-    checkSliceableWithBidirectionalIndex(expected, sliceable)
+    checkBidirectionalCollection(expected, sliceable)
   }
 
   /*
@@ -95,7 +95,7 @@ ${Suite}.test("${ArrayType}/Sliceable/Enums") {
   do {
     let expected = [[E.A, E.B], [E.B, E.C], [E.D], [E.A, E.B, E.D]]
     let sliceable = ${ArrayType}(expected)
-    checkSliceableWithBidirectionalIndex(
+    checkBidirectionalCollection(
       expected, sliceable, SourceLocStack().withCurrentLoc())
   }
   */

validation-test/stdlib/CollectionType.swift.gyb

@@ -474,8 +474,8 @@ CollectionTypeTests.test("Collection.makeIterator()/DefaultImplementation") {
     }
 
     checkCollection(
-      collection,
+      Array(1..<count+1).map(OpaqueValue.init) as [OpaqueValue<Int>],
-      expected: Array(1..<count+1).map(OpaqueValue.init) as [OpaqueValue<Int>]
+      collection
     ) { $0.value == $1.value }
   }
 }
@@ -547,8 +547,8 @@ CollectionTypeTests.test("Collection.makeIterator()/CustomImplementation") {
     }
 
     checkCollection(
+      Array(1..<count+1).map(OpaqueValue.init) as [OpaqueValue<Int>],
       collection,
-      expected: Array(1..<count+1).map(OpaqueValue.init) as [OpaqueValue<Int>],
       resiliencyChecks: .none) { $0.value == $1.value }
   }
 }

validation-test/stdlib/Data.swift

@@ -7,6 +7,7 @@ import StdlibCollectionUnittest
 import Foundation
 
 var DataTestSuite = TestSuite("Data")
+
 DataTestSuite.test("Data.Iterator semantics") {
   // Empty data
   checkSequence([], Data())
@@ -45,7 +46,10 @@ DataTestSuite.test("Data SubSequence") {
   let array: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7]
   var data = Data(bytes: array)
 
-  checkRandomAccessCollection(array, data)
+  // FIXME: Iteration over Data slices is currently broken:
+  // [SR-4292] Foundation.Data.copyBytes is zero-based.
+  //           Data.Iterator assumes it is not.
+  // checkRandomAccessCollection(array, data)
 
   for i in 0..<data.count {
     for j in i..<data.count {

validation-test/stdlib/Slice.swift.gyb

@@ -83,8 +83,8 @@ SliceTests.test("${Slice}/init(base:bounds:)") {
     expectType(${Slice}<${Collection}<OpaqueValue<Int>>>.self, &slice)
 
     checkCollection(
+      test.expected,
       slice,
-      expected: test.expected,
       stackTrace: SourceLocStack().with(test.loc))
       { $0.value == $1.value }
   }

validation-test/stdlib/Unicode.swift.gyb

@@ -1607,7 +1607,7 @@ func checkUTF8View(_ expected: [UInt8], _ subject: String,
 
 func checkUTF16View(_ expected: [UInt16], _ subject: String,
     _ stackTrace: SourceLocStack) {
-  checkSliceableWithBidirectionalIndex(expected, subject.utf16)
+  checkBidirectionalCollection(expected, subject.utf16)
 }
 
 func forStringsWithUnpairedSurrogates(_ checkClosure: (UTF16Test, String) -> Void) {
@@ -1848,7 +1848,7 @@ StringCookedViews.test("UnicodeScalars").forEach(in: utfTests) {
   test in
 
   let subject = NonContiguousNSString(test.utf32) as String
-  checkSliceableWithBidirectionalIndex(
+  checkBidirectionalCollection(
     test.unicodeScalars, subject.unicodeScalars)
 }
 
@@ -1858,7 +1858,7 @@ StringCookedViews.test("UnicodeScalars/StringsWithUnpairedSurrogates") {
     let expectedScalars = (test.scalarsHead + test.scalarsRepairedTail).map {
       UnicodeScalar($0)!
     }
-    checkSliceableWithBidirectionalIndex(
+    checkBidirectionalCollection(
       expectedScalars, subject.unicodeScalars)
   }
 }

validation-test/stdlib/UnicodeTrie.swift.gyb

@@ -144,7 +144,7 @@ func checkGraphemeClusterSegmentation(
   )
 
   let expectedCharacters: [Character] = Array(subject.characters)
-  checkSliceableWithBidirectionalIndex(expectedCharacters, subject.characters)
+  checkBidirectionalCollection(expectedCharacters, subject.characters)
 }
 
 func checkGraphemeClusterSegmentation(

validation-test/stdlib/UnsafeBufferPointer.swift.gyb

@@ -475,15 +475,15 @@ ${SelfName}TestSuite.test("RandomAccessCollection") {
   defer { SubscriptGetTest.deallocateFor${'Raw' if IsRaw else ''}Buffer(
       memoryCopy, count: elementCount) }
 
-  var buffer = SubscriptGetTest.create${SelfName}(from: memory)
+  let buffer = SubscriptGetTest.create${SelfName}(from: memory)
-  var expected = UnsafeMutable${'Raw' if IsRaw else ''}BufferPointer(
+  let expected = UnsafeMutable${'Raw' if IsRaw else ''}BufferPointer(
     start: memoryCopy, count: buffer.count)
 
 %   if IsRaw:
   expected.copyBytes(from: buffer)
   checkRandomAccessCollection(expected, buffer) { $0 == $1 }
 %   else:
-  expected.baseAddress!.initialize(from: buffer)
+  _ = expected.initialize(from: buffer)
   checkRandomAccessCollection(expected, buffer) { $0.value == $1.value }
 %   end
 }
@@ -542,15 +542,15 @@ ${SelfName}TestSuite.test("subscript/${RangeName}/get").forEach(in: subscriptGet
     )
   }
 }
-%    end
+%   end # RangeName
-
+% end # SelfName, IsMutable, IsRaw, SelfType, PointerType
-% end
 
 % for (SelfName, IsRaw) in [
 %   ('UnsafeMutableBufferPointer', False),
 %   ('UnsafeMutableRawBufferPointer', True)
 % ]:
 %   for RangeName in ['range', 'countableRange', 'closedRange', 'countableClosedRange']:
+
 UnsafeMutable${'Raw' if IsRaw else ''}BufferPointerTestSuite.test("subscript/${RangeName}/set")
 %     if not IsRaw:
   // UnsafeRawBuffer (currently) invokes Collection._failEarlyRangeCheck
@@ -585,7 +585,7 @@ UnsafeMutable${'Raw' if IsRaw else ''}BufferPointerTestSuite.test("subscript/${R
       return false
     }
   }
-%      else:
+%      else: # !closed
   expectedValues = test.expectedValues
   replacementValues = test.replacementValues
   let isOutOfBounds: () -> Bool = {
@@ -596,7 +596,7 @@ UnsafeMutable${'Raw' if IsRaw else ''}BufferPointerTestSuite.test("subscript/${R
       return false
     }
   }
-%      end
+%      end # !closed
 
   var memory = SubscriptSetTest.allocateFor${'Raw' if IsRaw else ''}Buffer(
     count: elementCount)
@@ -640,7 +640,9 @@ UnsafeMutable${'Raw' if IsRaw else ''}BufferPointerTestSuite.test("subscript/${R
     )
   }
 }
+
 %   end # RangeName
+
 % end # SelfName
 
 UnsafeMutableRawBufferPointerTestSuite.test("changeElementViaBuffer") {