| // 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 |
| |
