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
|
%{
# This is a template of validation-test/stdlib/Collection/LazyMap*.swift
#
# cd validation-test/stdlib/Collection
# ../../../utils/gyb --line-directive="" Inputs/LazyMapTemplate.swift.gyb | ../../../utils/split_file.py
variations = [
('', 'Sequence'),
('', 'Collection'),
('Bidirectional', 'Collection'),
('RandomAccess', 'Collection')
]
}%
% for (traversal, kind) in variations:
// BEGIN LazyMap${traversal}${kind}.swift
// -*- swift -*-
//===----------------------------------------------------------------------===//
// Automatically Generated From validation-test/stdlib/Collection/Inputs/LazyMapTemplate.swift.gyb
// Do Not Edit Directly!
//===----------------------------------------------------------------------===//
// RUN: %target-run-simple-swift
// REQUIRES: executable_test
import StdlibUnittest
import StdlibCollectionUnittest
var CollectionTests = TestSuite("Collection")
// Test collections using value types as elements.
CollectionTests.add${traversal}${kind}Tests(
make${kind}: { (elements: [OpaqueValue<Int>]) -> LazyMap${traversal}${kind}<Minimal${traversal}${kind}<OpaqueValue<Int>>, OpaqueValue<Int>> in
Minimal${traversal}${kind}(elements: elements).lazy.map(identity)
},
wrapValue: identity,
extractValue: identity,
make${kind}OfEquatable: { (elements: [MinimalEquatableValue]) -> LazyMap${traversal}${kind}<Minimal${traversal}${kind}<MinimalEquatableValue>, MinimalEquatableValue> in
Minimal${traversal}${kind}(elements: elements).lazy.map(identityEq)
},
wrapValueIntoEquatable: identityEq,
extractValueFromEquatable: identityEq
)
// Test collections using reference types as elements.
CollectionTests.add${traversal}${kind}Tests(
make${kind}: { (elements: [LifetimeTracked]) -> LazyMap${traversal}${kind}<Minimal${traversal}${kind}<LifetimeTracked>, LifetimeTracked> in
Minimal${traversal}${kind}(elements: elements).lazy.map { $0 }
},
wrapValue: { (element: OpaqueValue<Int>) in
LifetimeTracked(element.value, identity: element.identity)
},
extractValue: { (element: LifetimeTracked) in
OpaqueValue(element.value, identity: element.identity)
},
make${kind}OfEquatable: { (elements: [LifetimeTracked]) -> LazyMap${traversal}${kind}<Minimal${traversal}${kind}<LifetimeTracked>, LifetimeTracked> in
Minimal${traversal}${kind}(elements: elements).lazy.map { $0 }
},
wrapValueIntoEquatable: { (element: MinimalEquatableValue) in
LifetimeTracked(element.value, identity: element.identity)
},
extractValueFromEquatable: { (element: LifetimeTracked) in
MinimalEquatableValue(element.value, identity: element.identity)
}
)
// Test sequence instances and iterators.
CollectionTests.test("LazyMapCollection instances (${traversal}${kind})") {
do {
let expected = ["convent", "conform", "constrict", "condone"]
let base = ["vent", "form", "strict", "done"]
% if kind == 'Sequence':
checkSequence(
expected,
MinimalSequence(elements: base).lazy.map { "con" + $0 })
% elif traversal == '' and kind == 'Collection':
checkForwardCollection(expected,
MinimalCollection(elements: base).lazy.map { "con" + $0 },
sameValue: { $0 == $1 })
% else:
check${traversal}${kind}(expected,
Minimal${traversal}${kind}(elements: base).lazy.map { "con" + $0 },
sameValue: { $0 == $1 })
% end
}
do {
let expected = [1, 4, 9, 16, 25, 36, 49, 64]
let base = [1, 2, 3, 4, 5, 6, 7, 8]
% if kind == 'Sequence':
checkSequence(
expected,
MinimalSequence(elements: base).lazy.map { $0 * $0 })
% elif traversal == '' and kind == 'Collection':
checkForwardCollection(expected,
MinimalCollection(elements: base).lazy.map { $0 * $0 },
sameValue: { $0 == $1 })
% else:
check${traversal}${kind}(
expected,
Minimal${traversal}${kind}(elements: base).lazy.map { $0 * $0 },
sameValue: { $0 == $1 })
% end
}
}
runAllTests()
% end # for (traversal, kind) in variations
|
