mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
879 lines
29 KiB
Swift
879 lines
29 KiB
Swift
// Copyright (c) 2014 - 2017 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
|
|
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// RUN: %target-run-simple-swift
|
|
// REQUIRES: executable_test
|
|
// REQUIRES: objc_interop
|
|
|
|
// Requires swift-version 4
|
|
// UNSUPPORTED: swift_test_mode_optimize_none_with_implicit_dynamic
|
|
|
|
import Foundation
|
|
|
|
#if FOUNDATION_XCTEST
|
|
import XCTest
|
|
class TestIndexSetSuper : XCTestCase { }
|
|
#else
|
|
import StdlibUnittest
|
|
class TestIndexSetSuper { }
|
|
#endif
|
|
|
|
class TestIndexSet : TestIndexSetSuper {
|
|
|
|
func testEnumeration() {
|
|
let someIndexes = IndexSet(integersIn: 3...4)
|
|
let first = someIndexes.startIndex
|
|
let last = someIndexes.endIndex
|
|
|
|
expectNotEqual(first, last)
|
|
|
|
var count = 0
|
|
var firstValue = 0
|
|
var secondValue = 0
|
|
for v in someIndexes {
|
|
if count == 0 { firstValue = v }
|
|
if count == 1 { secondValue = v }
|
|
count += 1
|
|
}
|
|
|
|
expectEqual(2, count)
|
|
expectEqual(3, firstValue)
|
|
expectEqual(4, secondValue)
|
|
}
|
|
|
|
func testSubsequence() {
|
|
var someIndexes = IndexSet(integersIn: 1..<3)
|
|
someIndexes.insert(integersIn: 10..<20)
|
|
|
|
let intersectingRange = someIndexes.indexRange(in: 5..<21)
|
|
expectFalse(intersectingRange.isEmpty)
|
|
|
|
let sub = someIndexes[intersectingRange]
|
|
var count = 0
|
|
for i in sub {
|
|
if count == 0 {
|
|
expectEqual(10, i)
|
|
}
|
|
if count == 9 {
|
|
expectEqual(19, i)
|
|
}
|
|
count += 1
|
|
}
|
|
expectEqual(count, 10)
|
|
}
|
|
|
|
func testIndexRange() {
|
|
var someIndexes = IndexSet(integersIn: 1..<3)
|
|
someIndexes.insert(integersIn: 10..<20)
|
|
|
|
var r : Range<IndexSet.Index>
|
|
|
|
r = someIndexes.indexRange(in: 1..<3)
|
|
expectEqual(1, someIndexes[r.lowerBound])
|
|
expectEqual(10, someIndexes[r.upperBound])
|
|
|
|
r = someIndexes.indexRange(in: 0..<0)
|
|
expectEqual(r.lowerBound, r.upperBound)
|
|
|
|
r = someIndexes.indexRange(in: 100..<201)
|
|
expectEqual(r.lowerBound, r.upperBound)
|
|
expectTrue(r.isEmpty)
|
|
|
|
r = someIndexes.indexRange(in: 0..<100)
|
|
expectEqual(r.lowerBound, someIndexes.startIndex)
|
|
expectEqual(r.upperBound, someIndexes.endIndex)
|
|
|
|
r = someIndexes.indexRange(in: 1..<11)
|
|
expectEqual(1, someIndexes[r.lowerBound])
|
|
expectEqual(11, someIndexes[r.upperBound])
|
|
|
|
let empty = IndexSet()
|
|
expectTrue(empty.indexRange(in: 1..<3).isEmpty)
|
|
}
|
|
|
|
func testMutation() {
|
|
var someIndexes = IndexSet(integersIn: 1..<3)
|
|
someIndexes.insert(3)
|
|
someIndexes.insert(4)
|
|
someIndexes.insert(5)
|
|
|
|
someIndexes.insert(10)
|
|
someIndexes.insert(11)
|
|
|
|
expectEqual(someIndexes.count, 7)
|
|
|
|
someIndexes.remove(11)
|
|
|
|
expectEqual(someIndexes.count, 6)
|
|
|
|
someIndexes.insert(integersIn: 100...101)
|
|
expectEqual(8, someIndexes.count)
|
|
expectEqual(2, someIndexes.count(in: 100...101))
|
|
|
|
someIndexes.remove(integersIn: 100...101)
|
|
expectEqual(6, someIndexes.count)
|
|
expectEqual(0, someIndexes.count(in: 100...101))
|
|
|
|
someIndexes.insert(integersIn: 200..<202)
|
|
expectEqual(8, someIndexes.count)
|
|
expectEqual(2, someIndexes.count(in: 200..<202))
|
|
|
|
someIndexes.remove(integersIn: 200..<202)
|
|
expectEqual(6, someIndexes.count)
|
|
expectEqual(0, someIndexes.count(in: 200..<202))
|
|
}
|
|
|
|
func testContainsAndIntersects() {
|
|
let someIndexes = IndexSet(integersIn: 1..<10)
|
|
|
|
expectTrue(someIndexes.contains(integersIn: 1..<10))
|
|
expectTrue(someIndexes.contains(integersIn: 1...9))
|
|
expectTrue(someIndexes.contains(integersIn: 2..<10))
|
|
expectTrue(someIndexes.contains(integersIn: 2...9))
|
|
expectTrue(someIndexes.contains(integersIn: 1..<9))
|
|
expectTrue(someIndexes.contains(integersIn: 1...8))
|
|
|
|
expectFalse(someIndexes.contains(integersIn: 0..<10))
|
|
expectFalse(someIndexes.contains(integersIn: 0...9))
|
|
expectFalse(someIndexes.contains(integersIn: 2..<11))
|
|
expectFalse(someIndexes.contains(integersIn: 2...10))
|
|
expectFalse(someIndexes.contains(integersIn: 0..<9))
|
|
expectFalse(someIndexes.contains(integersIn: 0...8))
|
|
|
|
expectTrue(someIndexes.intersects(integersIn: 1..<10))
|
|
expectTrue(someIndexes.intersects(integersIn: 1...9))
|
|
expectTrue(someIndexes.intersects(integersIn: 2..<10))
|
|
expectTrue(someIndexes.intersects(integersIn: 2...9))
|
|
expectTrue(someIndexes.intersects(integersIn: 1..<9))
|
|
expectTrue(someIndexes.intersects(integersIn: 1...8))
|
|
|
|
expectTrue(someIndexes.intersects(integersIn: 0..<10))
|
|
expectTrue(someIndexes.intersects(integersIn: 0...9))
|
|
expectTrue(someIndexes.intersects(integersIn: 2..<11))
|
|
expectTrue(someIndexes.intersects(integersIn: 2...10))
|
|
expectTrue(someIndexes.intersects(integersIn: 0..<9))
|
|
expectTrue(someIndexes.intersects(integersIn: 0...8))
|
|
|
|
expectFalse(someIndexes.intersects(integersIn: 0..<0))
|
|
expectFalse(someIndexes.intersects(integersIn: 10...12))
|
|
expectFalse(someIndexes.intersects(integersIn: 10..<12))
|
|
}
|
|
|
|
func testIteration() {
|
|
var someIndexes = IndexSet(integersIn: 1..<5)
|
|
someIndexes.insert(integersIn: 8..<11)
|
|
someIndexes.insert(15)
|
|
|
|
let start = someIndexes.startIndex
|
|
let end = someIndexes.endIndex
|
|
|
|
// Count forwards
|
|
var i = start
|
|
var count = 0
|
|
while i != end {
|
|
count += 1
|
|
i = someIndexes.index(after: i)
|
|
}
|
|
expectEqual(8, count)
|
|
|
|
// Count backwards
|
|
i = end
|
|
count = 0
|
|
while i != start {
|
|
i = someIndexes.index(before: i)
|
|
count += 1
|
|
}
|
|
expectEqual(8, count)
|
|
|
|
// Count using a for loop
|
|
count = 0
|
|
for _ in someIndexes {
|
|
count += 1
|
|
}
|
|
expectEqual(8, count)
|
|
|
|
// Go the other way
|
|
count = 0
|
|
for _ in someIndexes.reversed() {
|
|
count += 1
|
|
}
|
|
expectEqual(8, count)
|
|
}
|
|
|
|
func testRangeIteration() {
|
|
var someIndexes = IndexSet(integersIn: 1..<5)
|
|
someIndexes.insert(integersIn: 8..<11)
|
|
someIndexes.insert(15)
|
|
|
|
var count = 0
|
|
for r in someIndexes.rangeView {
|
|
// print("\(r)")
|
|
count += 1
|
|
if count == 3 {
|
|
expectEqual(r, 15..<16)
|
|
}
|
|
}
|
|
expectEqual(3, count)
|
|
|
|
// Backwards
|
|
count = 0
|
|
for r in someIndexes.rangeView.reversed() {
|
|
// print("\(r)")
|
|
count += 1
|
|
if count == 3 {
|
|
expectEqual(r, 1..<5)
|
|
}
|
|
}
|
|
expectEqual(3, count)
|
|
}
|
|
|
|
func testSubrangeIteration() {
|
|
func expectRanges(_ ranges: [Range<IndexSet.RangeView.Index>], in view: IndexSet.RangeView) {
|
|
expectEqual(ranges.count, view.count)
|
|
|
|
for i in 0 ..< min(ranges.count, view.count) {
|
|
expectEqual(Range(ranges[i]), Range(view[i]))
|
|
}
|
|
}
|
|
|
|
// Inclusive ranges for test:
|
|
// 2-4, 8-10, 15-19, 30-39, 60-79
|
|
var indexes = IndexSet()
|
|
indexes.insert(integersIn: 2..<5)
|
|
indexes.insert(integersIn: 8...10)
|
|
indexes.insert(integersIn: Range(15..<20))
|
|
indexes.insert(integersIn: Range(30...39))
|
|
indexes.insert(integersIn: 60..<80)
|
|
|
|
// Empty ranges should yield no results:
|
|
expectRanges([], in: indexes.rangeView(of: 0..<0))
|
|
|
|
// Ranges below contained indexes should yield no results:
|
|
expectRanges([], in: indexes.rangeView(of: 0...1))
|
|
|
|
// Ranges starting below first index but overlapping should yield a result:
|
|
expectRanges([2..<3], in: indexes.rangeView(of: 0...2))
|
|
|
|
// Ranges starting below first index but enveloping a range should yield a result:
|
|
expectRanges([2..<5], in: indexes.rangeView(of: 0...6))
|
|
|
|
// Ranges within subranges should yield a result:
|
|
expectRanges([2..<5], in: indexes.rangeView(of: 2...4))
|
|
expectRanges([3..<5], in: indexes.rangeView(of: 3...4))
|
|
expectRanges([3..<4], in: indexes.rangeView(of: 3..<4))
|
|
|
|
// Ranges starting within subranges and going over the end should yield a result:
|
|
expectRanges([3..<5], in: indexes.rangeView(of: 3...6))
|
|
|
|
// Ranges not matching any indexes should yield no results:
|
|
expectRanges([], in: indexes.rangeView(of: 5...6))
|
|
expectRanges([], in: indexes.rangeView(of: 5..<8))
|
|
|
|
// Same as above -- overlapping with a range of indexes should slice it appropriately:
|
|
expectRanges([8..<9], in: indexes.rangeView(of: 6...8))
|
|
expectRanges([8..<11], in: indexes.rangeView(of: 8...10))
|
|
expectRanges([8..<11], in: indexes.rangeView(of: 8...13))
|
|
|
|
expectRanges([2..<5, 8..<10], in: indexes.rangeView(of: 0...9))
|
|
expectRanges([2..<5, 8..<11], in: indexes.rangeView(of: 0...12))
|
|
expectRanges([3..<5, 8..<11], in: indexes.rangeView(of: 3...14))
|
|
|
|
expectRanges([3..<5, 8..<11, 15..<18], in: indexes.rangeView(of: 3...17))
|
|
expectRanges([3..<5, 8..<11, 15..<20], in: indexes.rangeView(of: 3...20))
|
|
expectRanges([3..<5, 8..<11, 15..<20], in: indexes.rangeView(of: 3...21))
|
|
|
|
// Ranges inclusive of the end index should yield all of the contained ranges:
|
|
expectRanges([2..<5, 8..<11, 15..<20, 30..<40, 60..<80], in: indexes.rangeView(of: 0...80))
|
|
expectRanges([2..<5, 8..<11, 15..<20, 30..<40, 60..<80], in: indexes.rangeView(of: 2..<80))
|
|
expectRanges([2..<5, 8..<11, 15..<20, 30..<40, 60..<80], in: indexes.rangeView(of: 2...80))
|
|
|
|
// Ranges above the end index should yield no results:
|
|
expectRanges([], in: indexes.rangeView(of: 90..<90))
|
|
expectRanges([], in: indexes.rangeView(of: 90...90))
|
|
expectRanges([], in: indexes.rangeView(of: 90...100))
|
|
}
|
|
|
|
func testSlicing() {
|
|
var someIndexes = IndexSet(integersIn: 2..<5)
|
|
someIndexes.insert(integersIn: 8..<11)
|
|
someIndexes.insert(integersIn: 15..<20)
|
|
someIndexes.insert(integersIn: 30..<40)
|
|
someIndexes.insert(integersIn: 60..<80)
|
|
|
|
var r : Range<IndexSet.Index>
|
|
|
|
r = someIndexes.indexRange(in: 5..<25)
|
|
expectEqual(8, someIndexes[r.lowerBound])
|
|
expectEqual(19, someIndexes[someIndexes.index(before: r.upperBound)])
|
|
var count = 0
|
|
for _ in someIndexes[r] {
|
|
count += 1
|
|
}
|
|
|
|
expectEqual(8, someIndexes.count(in: 5..<25))
|
|
expectEqual(8, count)
|
|
|
|
r = someIndexes.indexRange(in: 100...199)
|
|
expectTrue(r.isEmpty)
|
|
|
|
let emptySlice = someIndexes[r]
|
|
expectEqual(0, emptySlice.count)
|
|
|
|
let boundarySlice = someIndexes[someIndexes.indexRange(in: 2..<3)]
|
|
expectEqual(1, boundarySlice.count)
|
|
|
|
let boundarySlice2 = someIndexes[someIndexes.indexRange(in: 79..<80)]
|
|
expectEqual(1, boundarySlice2.count)
|
|
|
|
let largeSlice = someIndexes[someIndexes.indexRange(in: 0..<100000)]
|
|
expectEqual(someIndexes.count, largeSlice.count)
|
|
}
|
|
|
|
func testEmptyIteration() {
|
|
var empty = IndexSet()
|
|
let start = empty.startIndex
|
|
let end = empty.endIndex
|
|
|
|
expectEqual(start, end)
|
|
|
|
var count = 0
|
|
for _ in empty {
|
|
count += 1
|
|
}
|
|
|
|
expectEqual(count, 0)
|
|
|
|
count = 0
|
|
for _ in empty.rangeView {
|
|
count += 1
|
|
}
|
|
|
|
expectEqual(count, 0)
|
|
|
|
empty.insert(5)
|
|
empty.remove(5)
|
|
|
|
count = 0
|
|
for _ in empty {
|
|
count += 1
|
|
}
|
|
expectEqual(count, 0)
|
|
|
|
count = 0
|
|
for _ in empty.rangeView {
|
|
count += 1
|
|
}
|
|
expectEqual(count, 0)
|
|
}
|
|
|
|
func testSubsequences() {
|
|
var someIndexes = IndexSet(integersIn: 1..<5)
|
|
someIndexes.insert(integersIn: 8..<11)
|
|
someIndexes.insert(15)
|
|
|
|
// Get a subsequence of this IndexSet
|
|
let range = someIndexes.indexRange(in: 4..<15)
|
|
let subSet = someIndexes[range]
|
|
|
|
expectEqual(subSet.count, 4)
|
|
|
|
// Iterate a subset
|
|
var count = 0
|
|
for _ in subSet {
|
|
count += 1
|
|
}
|
|
expectEqual(count, 4)
|
|
|
|
// And in reverse
|
|
count = 0
|
|
for _ in subSet.reversed() {
|
|
count += 1
|
|
}
|
|
expectEqual(count, 4)
|
|
}
|
|
|
|
func testFiltering() {
|
|
var someIndexes = IndexSet(integersIn: 1..<5)
|
|
someIndexes.insert(integersIn: 8..<11)
|
|
someIndexes.insert(15)
|
|
|
|
// An array
|
|
let resultArray = someIndexes.filter { $0 % 2 == 0 }
|
|
expectEqual(resultArray.count, 4)
|
|
|
|
let resultSet = someIndexes.filteredIndexSet { $0 % 2 == 0 }
|
|
expectEqual(resultSet.count, 4)
|
|
|
|
let resultOutsideRange = someIndexes.filteredIndexSet(in: 20..<30, includeInteger: { _ in return true } )
|
|
expectEqual(resultOutsideRange.count, 0)
|
|
|
|
let resultInRange = someIndexes.filteredIndexSet(in: 0..<16, includeInteger: { _ in return true } )
|
|
expectEqual(resultInRange.count, someIndexes.count)
|
|
}
|
|
|
|
func testFilteringRanges() {
|
|
var someIndexes = IndexSet(integersIn: 1..<5)
|
|
someIndexes.insert(integersIn: 8..<11)
|
|
someIndexes.insert(15)
|
|
|
|
let resultArray = someIndexes.rangeView.filter { $0.count > 1 }
|
|
expectEqual(resultArray.count, 2)
|
|
}
|
|
|
|
func testShift() {
|
|
var someIndexes = IndexSet(integersIn: 1..<5)
|
|
someIndexes.insert(integersIn: 8..<11)
|
|
someIndexes.insert(15)
|
|
|
|
let lastValue = someIndexes.last!
|
|
|
|
someIndexes.shift(startingAt: 13, by: 1)
|
|
|
|
// Count should not have changed
|
|
expectEqual(someIndexes.count, 8)
|
|
|
|
// But the last value should have
|
|
expectEqual(lastValue + 1, someIndexes.last!)
|
|
|
|
// Shift starting at something not in the set
|
|
someIndexes.shift(startingAt: 0, by: 1)
|
|
|
|
// Count should not have changed, again
|
|
expectEqual(someIndexes.count, 8)
|
|
|
|
// But the last value should have, again
|
|
expectEqual(lastValue + 2, someIndexes.last!)
|
|
}
|
|
|
|
func testSymmetricDifference() {
|
|
var is1 : IndexSet
|
|
var is2 : IndexSet
|
|
var expected : IndexSet
|
|
|
|
do {
|
|
is1 = IndexSet()
|
|
is1.insert(integersIn: 1..<3)
|
|
is1.insert(integersIn: 4..<11)
|
|
is1.insert(integersIn: 15..<21)
|
|
is1.insert(integersIn: 40..<51)
|
|
|
|
is2 = IndexSet()
|
|
is2.insert(integersIn: 5..<18)
|
|
is2.insert(integersIn: 45..<61)
|
|
|
|
expected = IndexSet()
|
|
expected.insert(integersIn: 1..<3)
|
|
expected.insert(4)
|
|
expected.insert(integersIn: 11..<15)
|
|
expected.insert(integersIn: 18..<21)
|
|
expected.insert(integersIn: 40..<45)
|
|
expected.insert(integersIn: 51..<61)
|
|
|
|
expectEqual(expected, is1.symmetricDifference(is2))
|
|
expectEqual(expected, is2.symmetricDifference(is1))
|
|
}
|
|
|
|
do {
|
|
is1 = IndexSet()
|
|
is1.insert(integersIn: 5..<18)
|
|
is1.insert(integersIn: 45..<61)
|
|
|
|
is2 = IndexSet()
|
|
is2.insert(integersIn: 5..<18)
|
|
is2.insert(integersIn: 45..<61)
|
|
|
|
expected = IndexSet()
|
|
expectEqual(expected, is1.symmetricDifference(is2))
|
|
expectEqual(expected, is2.symmetricDifference(is1))
|
|
}
|
|
|
|
do {
|
|
is1 = IndexSet(integersIn: 1..<10)
|
|
is2 = IndexSet(integersIn: 20..<30)
|
|
|
|
expected = IndexSet()
|
|
expected.insert(integersIn: 1..<10)
|
|
expected.insert(integersIn: 20..<30)
|
|
expectEqual(expected, is1.symmetricDifference(is2))
|
|
expectEqual(expected, is2.symmetricDifference(is1))
|
|
}
|
|
|
|
do {
|
|
is1 = IndexSet(integersIn: 1..<10)
|
|
is2 = IndexSet(integersIn: 1..<11)
|
|
expected = IndexSet(integer: 10)
|
|
expectEqual(expected, is1.symmetricDifference(is2))
|
|
expectEqual(expected, is2.symmetricDifference(is1))
|
|
}
|
|
|
|
do {
|
|
is1 = IndexSet(integer: 42)
|
|
is2 = IndexSet(integer: 42)
|
|
expectEqual(IndexSet(), is1.symmetricDifference(is2))
|
|
expectEqual(IndexSet(), is2.symmetricDifference(is1))
|
|
}
|
|
|
|
do {
|
|
is1 = IndexSet(integer: 1)
|
|
is1.insert(3)
|
|
is1.insert(5)
|
|
is1.insert(7)
|
|
|
|
is2 = IndexSet(integer: 0)
|
|
is2.insert(2)
|
|
is2.insert(4)
|
|
is2.insert(6)
|
|
|
|
expected = IndexSet(integersIn: 0..<8)
|
|
expectEqual(expected, is1.symmetricDifference(is2))
|
|
expectEqual(expected, is2.symmetricDifference(is1))
|
|
}
|
|
|
|
do {
|
|
is1 = IndexSet(integersIn: 0..<5)
|
|
is2 = IndexSet(integersIn: 3..<10)
|
|
|
|
expected = IndexSet(integersIn: 0..<3)
|
|
expected.insert(integersIn: 5..<10)
|
|
|
|
expectEqual(expected, is1.symmetricDifference(is2))
|
|
expectEqual(expected, is2.symmetricDifference(is1))
|
|
}
|
|
|
|
do {
|
|
is1 = IndexSet([0, 2])
|
|
is2 = IndexSet([0, 1, 2])
|
|
expectEqual(IndexSet(integer: 1), is1.symmetricDifference(is2))
|
|
}
|
|
}
|
|
|
|
func testIntersection() {
|
|
var is1 : IndexSet
|
|
var is2 : IndexSet
|
|
var expected : IndexSet
|
|
|
|
do {
|
|
is1 = IndexSet()
|
|
is1.insert(integersIn: 1..<3)
|
|
is1.insert(integersIn: 4..<11)
|
|
is1.insert(integersIn: 15..<21)
|
|
is1.insert(integersIn: 40..<51)
|
|
|
|
is2 = IndexSet()
|
|
is2.insert(integersIn: 5..<18)
|
|
is2.insert(integersIn: 45..<61)
|
|
|
|
expected = IndexSet()
|
|
expected.insert(integersIn: 5..<11)
|
|
expected.insert(integersIn: 15..<18)
|
|
expected.insert(integersIn: 45..<51)
|
|
|
|
expectEqual(expected, is1.intersection(is2))
|
|
expectEqual(expected, is2.intersection(is1))
|
|
}
|
|
|
|
do {
|
|
is1 = IndexSet()
|
|
is1.insert(integersIn: 5..<11)
|
|
is1.insert(integersIn: 20..<31)
|
|
|
|
is2 = IndexSet()
|
|
is2.insert(integersIn: 11..<20)
|
|
is2.insert(integersIn: 31..<40)
|
|
|
|
expectEqual(IndexSet(), is1.intersection(is2))
|
|
expectEqual(IndexSet(), is2.intersection(is1))
|
|
}
|
|
|
|
do {
|
|
is1 = IndexSet(integer: 42)
|
|
is2 = IndexSet(integer: 42)
|
|
expectEqual(IndexSet(integer: 42), is1.intersection(is2))
|
|
}
|
|
|
|
do {
|
|
is1 = IndexSet(integer: 1)
|
|
is1.insert(3)
|
|
is1.insert(5)
|
|
is1.insert(7)
|
|
|
|
is2 = IndexSet(integer: 0)
|
|
is2.insert(2)
|
|
is2.insert(4)
|
|
is2.insert(6)
|
|
|
|
expected = IndexSet()
|
|
expectEqual(expected, is1.intersection(is2))
|
|
expectEqual(expected, is2.intersection(is1))
|
|
}
|
|
|
|
do {
|
|
is1 = IndexSet(integersIn: 0..<5)
|
|
is2 = IndexSet(integersIn: 4..<10)
|
|
|
|
expected = IndexSet(integer: 4)
|
|
|
|
expectEqual(expected, is1.intersection(is2))
|
|
expectEqual(expected, is2.intersection(is1))
|
|
}
|
|
|
|
do {
|
|
is1 = IndexSet([0, 2])
|
|
is2 = IndexSet([0, 1, 2])
|
|
expectEqual(is1, is1.intersection(is2))
|
|
}
|
|
}
|
|
|
|
func testUnion() {
|
|
var is1 : IndexSet
|
|
var is2 : IndexSet
|
|
var expected : IndexSet
|
|
|
|
do {
|
|
is1 = IndexSet()
|
|
is1.insert(integersIn: 1..<3)
|
|
is1.insert(integersIn: 4..<11)
|
|
is1.insert(integersIn: 15..<21)
|
|
is1.insert(integersIn: 40..<51)
|
|
|
|
is2 = IndexSet()
|
|
is2.insert(integersIn: 5..<18)
|
|
is2.insert(integersIn: 45..<61)
|
|
|
|
expected = IndexSet()
|
|
expected.insert(integersIn: 1..<3)
|
|
expected.insert(integersIn: 4..<21)
|
|
expected.insert(integersIn: 40..<61)
|
|
|
|
expectEqual(expected, is1.union(is2))
|
|
expectEqual(expected, is2.union(is1))
|
|
}
|
|
|
|
do {
|
|
is1 = IndexSet()
|
|
is1.insert(integersIn: 5..<11)
|
|
is1.insert(integersIn: 20..<31)
|
|
|
|
is2 = IndexSet()
|
|
is2.insert(integersIn: 11..<20)
|
|
is2.insert(integersIn: 31..<40)
|
|
|
|
expected = IndexSet()
|
|
expected.insert(integersIn: 5..<11)
|
|
expected.insert(integersIn: 20..<31)
|
|
expected.insert(integersIn: 11..<20)
|
|
expected.insert(integersIn: 31..<40)
|
|
|
|
expectEqual(expected, is1.union(is2))
|
|
expectEqual(expected, is2.union(is1))
|
|
}
|
|
|
|
do {
|
|
is1 = IndexSet(integer: 42)
|
|
is2 = IndexSet(integer: 42)
|
|
|
|
expectEqual(IndexSet(integer: 42), is1.union(is2))
|
|
}
|
|
|
|
do {
|
|
is1 = IndexSet()
|
|
is1.insert(integersIn: 5..<10)
|
|
is1.insert(integersIn: 15..<20)
|
|
|
|
is2 = IndexSet()
|
|
is2.insert(integersIn: 1..<4)
|
|
is2.insert(integersIn: 15..<20)
|
|
|
|
expected = IndexSet()
|
|
expected.insert(integersIn: 1..<4)
|
|
expected.insert(integersIn: 5..<10)
|
|
expected.insert(integersIn: 15..<20)
|
|
|
|
expectEqual(expected, is1.union(is2))
|
|
expectEqual(expected, is2.union(is1))
|
|
}
|
|
|
|
expectEqual(IndexSet(), IndexSet().union(IndexSet()))
|
|
|
|
do {
|
|
is1 = IndexSet(integer: 1)
|
|
is1.insert(3)
|
|
is1.insert(5)
|
|
is1.insert(7)
|
|
|
|
is2 = IndexSet(integer: 0)
|
|
is2.insert(2)
|
|
is2.insert(4)
|
|
is2.insert(6)
|
|
|
|
expected = IndexSet()
|
|
expectEqual(expected, is1.intersection(is2))
|
|
expectEqual(expected, is2.intersection(is1))
|
|
}
|
|
|
|
do {
|
|
is1 = IndexSet(integersIn: 0..<5)
|
|
is2 = IndexSet(integersIn: 3..<10)
|
|
|
|
expected = IndexSet(integersIn: 0..<10)
|
|
|
|
expectEqual(expected, is1.union(is2))
|
|
expectEqual(expected, is2.union(is1))
|
|
}
|
|
|
|
do {
|
|
is1 = IndexSet()
|
|
is1.insert(2)
|
|
is1.insert(6)
|
|
is1.insert(21)
|
|
is1.insert(22)
|
|
|
|
is2 = IndexSet()
|
|
is2.insert(8)
|
|
is2.insert(14)
|
|
is2.insert(21)
|
|
is2.insert(22)
|
|
is2.insert(24)
|
|
|
|
expected = IndexSet()
|
|
expected.insert(2)
|
|
expected.insert(6)
|
|
expected.insert(21)
|
|
expected.insert(22)
|
|
expected.insert(8)
|
|
expected.insert(14)
|
|
expected.insert(21)
|
|
expected.insert(22)
|
|
expected.insert(24)
|
|
|
|
expectEqual(expected, is1.union(is2))
|
|
expectEqual(expected, is2.union(is1))
|
|
}
|
|
}
|
|
|
|
func test_findIndex() {
|
|
var i = IndexSet()
|
|
|
|
// Verify nil result for empty sets
|
|
expectEqual(nil, i.first)
|
|
expectEqual(nil, i.last)
|
|
expectEqual(nil, i.integerGreaterThan(5))
|
|
expectEqual(nil, i.integerLessThan(5))
|
|
expectEqual(nil, i.integerGreaterThanOrEqualTo(5))
|
|
expectEqual(nil, i.integerLessThanOrEqualTo(5))
|
|
|
|
i.insert(integersIn: 5..<10)
|
|
i.insert(integersIn: 15..<20)
|
|
|
|
// Verify non-nil result
|
|
expectEqual(5, i.first)
|
|
expectEqual(19, i.last)
|
|
|
|
expectEqual(nil, i.integerGreaterThan(19))
|
|
expectEqual(5, i.integerGreaterThan(3))
|
|
|
|
expectEqual(nil, i.integerLessThan(5))
|
|
expectEqual(5, i.integerLessThan(6))
|
|
|
|
expectEqual(nil, i.integerGreaterThanOrEqualTo(20))
|
|
expectEqual(19, i.integerGreaterThanOrEqualTo(19))
|
|
|
|
expectEqual(nil, i.integerLessThanOrEqualTo(4))
|
|
expectEqual(5, i.integerLessThanOrEqualTo(5))
|
|
}
|
|
|
|
// MARK: -
|
|
// MARK: Performance Testing
|
|
|
|
func largeIndexSet() -> IndexSet {
|
|
var result = IndexSet()
|
|
|
|
for i in 1..<10000 {
|
|
let start = i * 10
|
|
let end = start + 9
|
|
result.insert(integersIn: start..<end + 1)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func testIndexingPerformance() {
|
|
/*
|
|
let set = largeIndexSet()
|
|
self.measureBlock {
|
|
var count = 0
|
|
while count < 20 {
|
|
for _ in set {
|
|
}
|
|
count += 1
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
|
|
func test_AnyHashableContainingIndexSet() {
|
|
let values: [IndexSet] = [
|
|
IndexSet([0, 1]),
|
|
IndexSet([0, 1, 2]),
|
|
IndexSet([0, 1, 2]),
|
|
]
|
|
let anyHashables = values.map(AnyHashable.init)
|
|
expectEqual(IndexSet.self, type(of: anyHashables[0].base))
|
|
expectEqual(IndexSet.self, type(of: anyHashables[1].base))
|
|
expectEqual(IndexSet.self, type(of: anyHashables[2].base))
|
|
expectNotEqual(anyHashables[0], anyHashables[1])
|
|
expectEqual(anyHashables[1], anyHashables[2])
|
|
}
|
|
|
|
func test_AnyHashableCreatedFromNSIndexSet() {
|
|
let values: [NSIndexSet] = [
|
|
NSIndexSet(index: 0),
|
|
NSIndexSet(index: 1),
|
|
NSIndexSet(index: 1),
|
|
]
|
|
let anyHashables = values.map(AnyHashable.init)
|
|
expectEqual(IndexSet.self, type(of: anyHashables[0].base))
|
|
expectEqual(IndexSet.self, type(of: anyHashables[1].base))
|
|
expectEqual(IndexSet.self, type(of: anyHashables[2].base))
|
|
expectNotEqual(anyHashables[0], anyHashables[1])
|
|
expectEqual(anyHashables[1], anyHashables[2])
|
|
}
|
|
|
|
func test_unconditionallyBridgeFromObjectiveC() {
|
|
expectEqual(IndexSet(), IndexSet._unconditionallyBridgeFromObjectiveC(nil))
|
|
}
|
|
}
|
|
|
|
#if !FOUNDATION_XCTEST
|
|
var IndexSetTests = TestSuite("TestIndexSet")
|
|
IndexSetTests.test("testSymmetricDifference") { TestIndexSet().testSymmetricDifference() }
|
|
IndexSetTests.test("testIntersection") { TestIndexSet().testIntersection() }
|
|
IndexSetTests.test("testUnion") { TestIndexSet().testUnion() }
|
|
IndexSetTests.test("testEnumeration") { TestIndexSet().testEnumeration() }
|
|
IndexSetTests.test("testSubsequence") { TestIndexSet().testSubsequence() }
|
|
IndexSetTests.test("testIndexRange") { TestIndexSet().testIndexRange() }
|
|
IndexSetTests.test("testMutation") { TestIndexSet().testMutation() }
|
|
IndexSetTests.test("testContainsAndIntersects") { TestIndexSet().testContainsAndIntersects() }
|
|
IndexSetTests.test("testIteration") { TestIndexSet().testIteration() }
|
|
IndexSetTests.test("testRangeIteration") { TestIndexSet().testRangeIteration() }
|
|
IndexSetTests.test("testSubrangeIteration") { TestIndexSet().testSubrangeIteration() }
|
|
IndexSetTests.test("testSlicing") { TestIndexSet().testSlicing() }
|
|
IndexSetTests.test("testEmptyIteration") { TestIndexSet().testEmptyIteration() }
|
|
IndexSetTests.test("testSubsequences") { TestIndexSet().testSubsequences() }
|
|
IndexSetTests.test("testFiltering") { TestIndexSet().testFiltering() }
|
|
IndexSetTests.test("testFilteringRanges") { TestIndexSet().testFilteringRanges() }
|
|
IndexSetTests.test("testShift") { TestIndexSet().testShift() }
|
|
IndexSetTests.test("test_findIndex") { TestIndexSet().test_findIndex() }
|
|
// IndexSetTests.test("testIndexingPerformance") { TestIndexSet().testIndexingPerformance() }
|
|
IndexSetTests.test("test_AnyHashableContainingIndexSet") { TestIndexSet().test_AnyHashableContainingIndexSet() }
|
|
IndexSetTests.test("test_AnyHashableCreatedFromNSIndexSet") { TestIndexSet().test_AnyHashableCreatedFromNSIndexSet() }
|
|
IndexSetTests.test("test_unconditionallyBridgeFromObjectiveC") { TestIndexSet().test_unconditionallyBridgeFromObjectiveC() }
|
|
runAllTests()
|
|
#endif
|
|
|