mirror of
https://github.com/apple/swift-collections
synced 2026-11-22 04:20:40 +00:00
203 lines
6.1 KiB
Swift
203 lines
6.1 KiB
Swift
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This source file is part of the Swift Collections open source project
|
|
//
|
|
// Copyright (c) 2014 - 2026 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
|
|
//
|
|
// SPDX-License-Identifier: Apache-2.0 WITH Swift-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Loosely adapted from https://github.com/apple/swift/tree/main/stdlib/private/StdlibCollectionUnittest
|
|
|
|
// FIXME: Port all of the collection validation tests from the Swift compiler codebase.
|
|
|
|
import XCTest
|
|
|
|
extension BidirectionalCollection {
|
|
func _indicesByIndexBefore() -> [Index] {
|
|
var result: [Index] = []
|
|
var i = endIndex
|
|
while i != startIndex {
|
|
i = index(before: i)
|
|
result.append(i)
|
|
}
|
|
result.reverse()
|
|
return result
|
|
}
|
|
|
|
func _indicesByFormIndexBefore() -> [Index] {
|
|
var result: [Index] = []
|
|
var i = endIndex
|
|
while i != startIndex {
|
|
formIndex(before: &i)
|
|
result.append(i)
|
|
}
|
|
result.reverse()
|
|
return result
|
|
}
|
|
}
|
|
|
|
public func checkBidirectionalCollection<C: BidirectionalCollection, S: Sequence>(
|
|
_ collection: C,
|
|
expectedContents: S,
|
|
maxSamples: Int? = nil,
|
|
file: StaticString = #filePath,
|
|
line: UInt = #line
|
|
) where C.Element: Equatable, S.Element == C.Element {
|
|
checkBidirectionalCollection(
|
|
collection,
|
|
expectedContents: expectedContents,
|
|
by: ==,
|
|
maxSamples: maxSamples,
|
|
file: file,
|
|
line: line)
|
|
}
|
|
|
|
public func checkBidirectionalCollection<C: BidirectionalCollection, S: Sequence>(
|
|
_ collection: C,
|
|
expectedContents: S,
|
|
by areEquivalent: (S.Element, S.Element) -> Bool,
|
|
maxSamples: Int? = nil,
|
|
file: StaticString = #filePath,
|
|
line: UInt = #line
|
|
) where S.Element == C.Element {
|
|
checkSequence(
|
|
{ collection }, expectedContents: expectedContents,
|
|
by: areEquivalent,
|
|
file: file, line: line)
|
|
_checkCollection(
|
|
collection, expectedContents: expectedContents,
|
|
by: areEquivalent,
|
|
maxSamples: maxSamples,
|
|
file: file, line: line)
|
|
_checkBidirectionalCollection(
|
|
collection, expectedContents: expectedContents,
|
|
by: areEquivalent,
|
|
maxSamples: maxSamples,
|
|
file: file, line: line)
|
|
}
|
|
|
|
public func _checkBidirectionalCollection_indexOffsetBy<
|
|
C: Collection
|
|
>(
|
|
_ collection: C,
|
|
expectedContents: [C.Element],
|
|
by areEquivalent: (C.Element, C.Element) -> Bool,
|
|
maxSamples: Int? = nil,
|
|
file: StaticString = #filePath,
|
|
line: UInt = #line
|
|
) {
|
|
var allIndices = collection._indicesByIndexAfter()
|
|
allIndices.append(collection.endIndex)
|
|
|
|
withSomeRanges(
|
|
"range",
|
|
in: 0 ..< allIndices.count - (1 as Int),
|
|
maxSamples: maxSamples
|
|
) { range in
|
|
let i = range.lowerBound
|
|
let j = range.upperBound
|
|
|
|
// Check `index(_,offsetBy:)` with negative offsets
|
|
let a = collection.index(allIndices[j], offsetBy: i - j)
|
|
expectEqual(a, allIndices[i])
|
|
if i < expectedContents.count {
|
|
expectEquivalent(
|
|
collection[a], expectedContents[i],
|
|
by: areEquivalent)
|
|
}
|
|
|
|
// Check `distance(from:to:)` with decreasing indices
|
|
let d = collection.distance(from: allIndices[j], to: allIndices[i])
|
|
expectEqual(d, i - j)
|
|
}
|
|
|
|
// Check `index(_,offsetBy:limitedBy:)`
|
|
let limits =
|
|
Set([0, allIndices.count - 1, allIndices.count / 2])
|
|
.sorted()
|
|
withEvery("limit", in: limits) { limit in
|
|
withEvery("i", in: 0 ..< allIndices.count) { i in
|
|
let min = -i - (limit <= i ? 2 : 0)
|
|
withEvery("delta", in: stride(from: 0, through: min, by: -1)) { delta in
|
|
let actual = collection.index(
|
|
allIndices[i],
|
|
offsetBy: delta,
|
|
limitedBy: allIndices[limit])
|
|
let j = i + delta
|
|
let expected = i < limit || j >= limit ? allIndices[j] : nil
|
|
expectEqual(actual, expected)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public func _checkBidirectionalCollection<C: BidirectionalCollection, S: Sequence>(
|
|
_ collection: C,
|
|
expectedContents: S,
|
|
by areEquivalent: (S.Element, S.Element) -> Bool,
|
|
maxSamples: Int? = nil,
|
|
file: StaticString = #filePath,
|
|
line: UInt = #line
|
|
) where S.Element == C.Element {
|
|
let entry = TestContext.current.push("checkBidirectionalCollection", file: file, line: line)
|
|
defer { TestContext.current.pop(entry) }
|
|
|
|
let expectedContents = Array(expectedContents)
|
|
|
|
// Check that `index(before:)` and `formIndex(before:)` are consistent with `index(after:)`.
|
|
let indicesByIndexAfter = collection._indicesByIndexAfter()
|
|
let indicesByIndexBefore = collection._indicesByIndexBefore()
|
|
let indicesByFormIndexBefore = collection._indicesByFormIndexBefore()
|
|
expectEqual(indicesByIndexBefore, indicesByIndexAfter)
|
|
expectEqual(indicesByFormIndexBefore, indicesByIndexAfter)
|
|
|
|
// Check contents using indexing.
|
|
let indexContents1 = indicesByIndexBefore.map { collection[$0] }
|
|
expectEquivalentElements(
|
|
indexContents1, expectedContents,
|
|
by: areEquivalent,
|
|
"\(expectedContents)")
|
|
let indexContents2 = indicesByFormIndexBefore.map { collection[$0] }
|
|
expectEquivalentElements(
|
|
indexContents2, expectedContents,
|
|
by: areEquivalent,
|
|
"\(expectedContents)")
|
|
|
|
// Check `distance(from:to:)`, `index(_:offsetBy)` and
|
|
// `index(_:offsetBy:limitedBy:)`.
|
|
_checkBidirectionalCollection_indexOffsetBy(
|
|
collection, expectedContents: expectedContents, by: areEquivalent)
|
|
|
|
var allIndices = indicesByIndexAfter
|
|
allIndices.append(collection.endIndex)
|
|
|
|
withSomeRanges(
|
|
"range",
|
|
in: 0 ..< allIndices.count - 1,
|
|
maxSamples: maxSamples
|
|
) { range in
|
|
let i = range.lowerBound
|
|
let j = range.upperBound
|
|
|
|
// Check slicing.
|
|
let slice = collection[allIndices[i] ..< allIndices[j]]
|
|
expectEqualElements(slice._indicesByIndexBefore(), allIndices[i ..< j])
|
|
expectEqualElements(slice._indicesByFormIndexBefore(), allIndices[i ..< j])
|
|
}
|
|
|
|
// Check the Indices associated type
|
|
if C.self != C.Indices.self && C.self != DefaultIndices<C>.self {
|
|
TestContext.current.withTrace("Indices") {
|
|
checkBidirectionalCollection(
|
|
collection.indices,
|
|
expectedContents: indicesByIndexAfter,
|
|
maxSamples: maxSamples)
|
|
}
|
|
}
|
|
}
|