1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
// -*- swift -*-
// RUN: %target-run-simple-swiftgyb
// REQUIRES: executable_test
%{
from gyb_stdlib_support import (
TRAVERSALS,
collectionTypeName
)
}%
import StdlibUnittest
import StdlibCollectionUnittest
/// Reference-type collection for testing the `base` property.
class ReferenceCollection : RandomAccessCollection {
typealias Index = Int
var startIndex: Int {
return 0
}
var endIndex: Int {
return 1
}
subscript(index: Int) -> String {
return ""
}
func index(after i: Int) -> Int {
return 1
}
func index(before i: Int) -> Int {
return 0
}
}
var SliceTests = TestSuite("Collection")
//===----------------------------------------------------------------------===//
// Slice<Base>
//===----------------------------------------------------------------------===//
% for Traversal in TRAVERSALS:
% for Mutable in [ False, True ]:
% for RangeReplaceable in [ False, True ]:
% Collection = 'Minimal' + collectionTypeName(traversal=Traversal, mutable=Mutable, rangeReplaceable=RangeReplaceable)
SliceTests.test("${Collection}.Slice/AssociatedTypes") {
do {
typealias Collection = ${Collection}<OpaqueValue<Int>>
typealias CollectionSlice = Slice<Collection>
expectSliceType(CollectionSlice.self)
expectCollectionAssociatedTypes(
collectionType: CollectionSlice.self,
iteratorType: IndexingIterator<CollectionSlice>.self,
subSequenceType: CollectionSlice.self,
indexType: MinimalIndex.self,
indicesType: Collection.Indices.self)
}
func checkStaticTypealiases1<Base : Collection>(_: Base) {
expectEqualType(Base.Index.self, Slice<Base>.Index.self)
}
func checkStaticTypealiases2<
Base : MutableCollection
>(_: Base) {
expectEqualType(Base.Index.self, Slice<Base>.Index.self)
}
}
SliceTests.test("${Collection}.Slice/init(base:bounds:)") {
for test in subscriptRangeTests {
let base = ${Collection}(elements: test.collection)
var slice = Slice(base: base, bounds: test.bounds(in: base))
expectType(Slice<${Collection}<OpaqueValue<Int>>>.self, &slice)
expectType(${Collection}<OpaqueValue<Int>>.SubSequence.self, &slice)
checkCollection(
test.expected,
slice,
stackTrace: SourceLocStack().with(test.loc))
{ $0.value == $1.value }
}
}
% if RangeReplaceable == False and Mutable == False:
SliceTests.test("${Collection}.Slice/baseProperty") {
let referenceCollection = ReferenceCollection()
let testSlice = Slice(base: referenceCollection, bounds: 0..<1)
expectTrue(testSlice.base === referenceCollection)
}
% end
SliceTests.test("${Collection}.Slice.{startIndex,endIndex}") {
for test in subscriptRangeTests {
let c = ${Collection}(elements: test.collection)
let bounds = test.bounds(in: c)
var slice = Slice(base: c, bounds: bounds)
expectType(Slice<${Collection}<OpaqueValue<Int>>>.self, &slice)
expectType(${Collection}<OpaqueValue<Int>>.SubSequence.self, &slice)
expectEqual(bounds.lowerBound, slice.startIndex)
expectEqual(bounds.upperBound, slice.endIndex)
}
}
% end
% end
% end
SliceTests.test("${Collection}.Slice.withContiguousStorageIfAvailable") {
for test in subscriptRangeTests {
let c = ${Collection}(elements: test.collection)
let bounds = test.bounds(in: c)
var slice = Slice(base: c, bounds: bounds)
let r = slice.withContiguousStorageIfAvailable { _ in }
expectNil(r) // None of the minimal collection types implement this.
}
}
//===----------------------------------------------------------------------===//
// MutableSlice<Base>
//===----------------------------------------------------------------------===//
extension Slice {
func _checkBaseSubSequenceElementIsElement() {
expectEqualType(
Element.self,
Iterator.Element.self)
expectEqualType(
Element.self,
Base.Iterator.Element.self)
expectEqualType(
Element.self,
Iterator.Element.self)
expectEqualType(
Element.self,
Base.SubSequence.Iterator.Element.self)
}
}
runAllTests()
|
