Skip to content

Commit 0913206

Browse files
author
Max Moiseev
committed
[tests] Generate LazyMap tests from the template
1 parent 02eca4a commit 0913206

File tree

5 files changed

+286
-95
lines changed

5 files changed

+286
-95
lines changed

‎validation-test/stdlib/Collection/LazyMapBidirectionalCollection.swift

Lines changed: 72 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,72 @@
1+
// -*- swift -*-
2+
3+
//===----------------------------------------------------------------------===//
4+
// Automatically Generated From validation-test/stdlib/Collection/Inputs/LazyMapTemplate.swift.gyb
5+
// Do Not Edit Directly!
6+
//===----------------------------------------------------------------------===//
7+
8+
// RUN: %target-run-simple-swift
9+
// REQUIRES: executable_test
10+
11+
import StdlibUnittest
12+
import StdlibCollectionUnittest
13+
14+
var CollectionTests = TestSuite("Collection")
15+
16+
// Test collections using value types as elements.
17+
CollectionTests.addBidirectionalCollectionTests(
18+
makeCollection: { (elements: [OpaqueValue<Int>]) -> LazyMapBidirectionalCollection<MinimalBidirectionalCollection<OpaqueValue<Int>>, OpaqueValue<Int>> in
19+
MinimalBidirectionalCollection(elements: elements).lazy.map(identity)
20+
},
21+
wrapValue: identity,
22+
extractValue: identity,
23+
makeCollectionOfEquatable: { (elements: [MinimalEquatableValue]) -> LazyMapBidirectionalCollection<MinimalBidirectionalCollection<MinimalEquatableValue>, MinimalEquatableValue> in
24+
MinimalBidirectionalCollection(elements: elements).lazy.map(identityEq)
25+
},
26+
wrapValueIntoEquatable: identityEq,
27+
extractValueFromEquatable: identityEq
28+
)
29+
30+
// Test collections using reference types as elements.
31+
CollectionTests.addBidirectionalCollectionTests(
32+
makeCollection: { (elements: [LifetimeTracked]) -> LazyMapBidirectionalCollection<MinimalBidirectionalCollection<LifetimeTracked>, LifetimeTracked> in
33+
MinimalBidirectionalCollection(elements: elements).lazy.map { $0 }
34+
},
35+
wrapValue: { (element: OpaqueValue<Int>) in
36+
LifetimeTracked(element.value, identity: element.identity)
37+
},
38+
extractValue: { (element: LifetimeTracked) in
39+
OpaqueValue(element.value, identity: element.identity)
40+
},
41+
makeCollectionOfEquatable: { (elements: [LifetimeTracked]) -> LazyMapBidirectionalCollection<MinimalBidirectionalCollection<LifetimeTracked>, LifetimeTracked> in
42+
MinimalBidirectionalCollection(elements: elements).lazy.map { $0 }
43+
},
44+
wrapValueIntoEquatable: { (element: MinimalEquatableValue) in
45+
LifetimeTracked(element.value, identity: element.identity)
46+
},
47+
extractValueFromEquatable: { (element: LifetimeTracked) in
48+
MinimalEquatableValue(element.value, identity: element.identity)
49+
}
50+
)
51+
52+
// Test sequence instances and iterators.
53+
CollectionTests.test("LazyMapCollection instances (BidirectionalCollection)") {
54+
do {
55+
let expected = ["convent", "conform", "constrict", "condone"]
56+
let base = ["vent", "form", "strict", "done"]
57+
checkBidirectionalCollection(expected,
58+
MinimalBidirectionalCollection(elements: base).lazy.map { "con" + $0 },
59+
sameValue: { $0 == $1 })
60+
}
61+
do {
62+
let expected = [1, 4, 9, 16, 25, 36, 49, 64]
63+
let base = [1, 2, 3, 4, 5, 6, 7, 8]
64+
checkBidirectionalCollection(
65+
expected,
66+
MinimalBidirectionalCollection(elements: base).lazy.map { $0 * $0 },
67+
sameValue: { $0 == $1 })
68+
}
69+
}
70+
71+
runAllTests()
72+

‎validation-test/stdlib/Collection/LazyMapCollection.swift

Lines changed: 71 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,71 @@
1+
// -*- swift -*-
2+
3+
//===----------------------------------------------------------------------===//
4+
// Automatically Generated From validation-test/stdlib/Collection/Inputs/LazyMapTemplate.swift.gyb
5+
// Do Not Edit Directly!
6+
//===----------------------------------------------------------------------===//
7+
8+
// RUN: %target-run-simple-swift
9+
// REQUIRES: executable_test
10+
11+
import StdlibUnittest
12+
import StdlibCollectionUnittest
13+
14+
var CollectionTests = TestSuite("Collection")
15+
16+
// Test collections using value types as elements.
17+
CollectionTests.addCollectionTests(
18+
makeCollection: { (elements: [OpaqueValue<Int>]) -> LazyMapCollection<MinimalCollection<OpaqueValue<Int>>, OpaqueValue<Int>> in
19+
MinimalCollection(elements: elements).lazy.map(identity)
20+
},
21+
wrapValue: identity,
22+
extractValue: identity,
23+
makeCollectionOfEquatable: { (elements: [MinimalEquatableValue]) -> LazyMapCollection<MinimalCollection<MinimalEquatableValue>, MinimalEquatableValue> in
24+
MinimalCollection(elements: elements).lazy.map(identityEq)
25+
},
26+
wrapValueIntoEquatable: identityEq,
27+
extractValueFromEquatable: identityEq
28+
)
29+
30+
// Test collections using reference types as elements.
31+
CollectionTests.addCollectionTests(
32+
makeCollection: { (elements: [LifetimeTracked]) -> LazyMapCollection<MinimalCollection<LifetimeTracked>, LifetimeTracked> in
33+
MinimalCollection(elements: elements).lazy.map { $0 }
34+
},
35+
wrapValue: { (element: OpaqueValue<Int>) in
36+
LifetimeTracked(element.value, identity: element.identity)
37+
},
38+
extractValue: { (element: LifetimeTracked) in
39+
OpaqueValue(element.value, identity: element.identity)
40+
},
41+
makeCollectionOfEquatable: { (elements: [LifetimeTracked]) -> LazyMapCollection<MinimalCollection<LifetimeTracked>, LifetimeTracked> in
42+
MinimalCollection(elements: elements).lazy.map { $0 }
43+
},
44+
wrapValueIntoEquatable: { (element: MinimalEquatableValue) in
45+
LifetimeTracked(element.value, identity: element.identity)
46+
},
47+
extractValueFromEquatable: { (element: LifetimeTracked) in
48+
MinimalEquatableValue(element.value, identity: element.identity)
49+
}
50+
)
51+
52+
// Test sequence instances and iterators.
53+
CollectionTests.test("LazyMapCollection instances (Collection)") {
54+
do {
55+
let expected = ["convent", "conform", "constrict", "condone"]
56+
let base = ["vent", "form", "strict", "done"]
57+
checkForwardCollection(expected,
58+
MinimalCollection(elements: base).lazy.map { "con" + $0 },
59+
sameValue: { $0 == $1 })
60+
}
61+
do {
62+
let expected = [1, 4, 9, 16, 25, 36, 49, 64]
63+
let base = [1, 2, 3, 4, 5, 6, 7, 8]
64+
checkForwardCollection(expected,
65+
MinimalCollection(elements: base).lazy.map { $0 * $0 },
66+
sameValue: { $0 == $1 })
67+
}
68+
}
69+
70+
runAllTests()
71+

‎validation-test/stdlib/Collection/LazyMapCollection.swift.gyb

Lines changed: 0 additions & 95 deletions
This file was deleted.

‎validation-test/stdlib/Collection/LazyMapRandomAccessCollection.swift

Lines changed: 72 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,72 @@
1+
// -*- swift -*-
2+
3+
//===----------------------------------------------------------------------===//
4+
// Automatically Generated From validation-test/stdlib/Collection/Inputs/LazyMapTemplate.swift.gyb
5+
// Do Not Edit Directly!
6+
//===----------------------------------------------------------------------===//
7+
8+
// RUN: %target-run-simple-swift
9+
// REQUIRES: executable_test
10+
11+
import StdlibUnittest
12+
import StdlibCollectionUnittest
13+
14+
var CollectionTests = TestSuite("Collection")
15+
16+
// Test collections using value types as elements.
17+
CollectionTests.addRandomAccessCollectionTests(
18+
makeCollection: { (elements: [OpaqueValue<Int>]) -> LazyMapRandomAccessCollection<MinimalRandomAccessCollection<OpaqueValue<Int>>, OpaqueValue<Int>> in
19+
MinimalRandomAccessCollection(elements: elements).lazy.map(identity)
20+
},
21+
wrapValue: identity,
22+
extractValue: identity,
23+
makeCollectionOfEquatable: { (elements: [MinimalEquatableValue]) -> LazyMapRandomAccessCollection<MinimalRandomAccessCollection<MinimalEquatableValue>, MinimalEquatableValue> in
24+
MinimalRandomAccessCollection(elements: elements).lazy.map(identityEq)
25+
},
26+
wrapValueIntoEquatable: identityEq,
27+
extractValueFromEquatable: identityEq
28+
)
29+
30+
// Test collections using reference types as elements.
31+
CollectionTests.addRandomAccessCollectionTests(
32+
makeCollection: { (elements: [LifetimeTracked]) -> LazyMapRandomAccessCollection<MinimalRandomAccessCollection<LifetimeTracked>, LifetimeTracked> in
33+
MinimalRandomAccessCollection(elements: elements).lazy.map { $0 }
34+
},
35+
wrapValue: { (element: OpaqueValue<Int>) in
36+
LifetimeTracked(element.value, identity: element.identity)
37+
},
38+
extractValue: { (element: LifetimeTracked) in
39+
OpaqueValue(element.value, identity: element.identity)
40+
},
41+
makeCollectionOfEquatable: { (elements: [LifetimeTracked]) -> LazyMapRandomAccessCollection<MinimalRandomAccessCollection<LifetimeTracked>, LifetimeTracked> in
42+
MinimalRandomAccessCollection(elements: elements).lazy.map { $0 }
43+
},
44+
wrapValueIntoEquatable: { (element: MinimalEquatableValue) in
45+
LifetimeTracked(element.value, identity: element.identity)
46+
},
47+
extractValueFromEquatable: { (element: LifetimeTracked) in
48+
MinimalEquatableValue(element.value, identity: element.identity)
49+
}
50+
)
51+
52+
// Test sequence instances and iterators.
53+
CollectionTests.test("LazyMapCollection instances (RandomAccessCollection)") {
54+
do {
55+
let expected = ["convent", "conform", "constrict", "condone"]
56+
let base = ["vent", "form", "strict", "done"]
57+
checkRandomAccessCollection(expected,
58+
MinimalRandomAccessCollection(elements: base).lazy.map { "con" + $0 },
59+
sameValue: { $0 == $1 })
60+
}
61+
do {
62+
let expected = [1, 4, 9, 16, 25, 36, 49, 64]
63+
let base = [1, 2, 3, 4, 5, 6, 7, 8]
64+
checkRandomAccessCollection(
65+
expected,
66+
MinimalRandomAccessCollection(elements: base).lazy.map { $0 * $0 },
67+
sameValue: { $0 == $1 })
68+
}
69+
}
70+
71+
runAllTests()
72+

‎validation-test/stdlib/Collection/LazyMapSequence.swift

Lines changed: 71 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,71 @@
1+
// -*- swift -*-
2+
3+
//===----------------------------------------------------------------------===//
4+
// Automatically Generated From validation-test/stdlib/Collection/Inputs/LazyMapTemplate.swift.gyb
5+
// Do Not Edit Directly!
6+
//===----------------------------------------------------------------------===//
7+
8+
// RUN: %target-run-simple-swift
9+
// REQUIRES: executable_test
10+
11+
import StdlibUnittest
12+
import StdlibCollectionUnittest
13+
14+
var CollectionTests = TestSuite("Collection")
15+
16+
// Test collections using value types as elements.
17+
CollectionTests.addSequenceTests(
18+
makeSequence: { (elements: [OpaqueValue<Int>]) -> LazyMapSequence<MinimalSequence<OpaqueValue<Int>>, OpaqueValue<Int>> in
19+
MinimalSequence(elements: elements).lazy.map(identity)
20+
},
21+
wrapValue: identity,
22+
extractValue: identity,
23+
makeSequenceOfEquatable: { (elements: [MinimalEquatableValue]) -> LazyMapSequence<MinimalSequence<MinimalEquatableValue>, MinimalEquatableValue> in
24+
MinimalSequence(elements: elements).lazy.map(identityEq)
25+
},
26+
wrapValueIntoEquatable: identityEq,
27+
extractValueFromEquatable: identityEq
28+
)
29+
30+
// Test collections using reference types as elements.
31+
CollectionTests.addSequenceTests(
32+
makeSequence: { (elements: [LifetimeTracked]) -> LazyMapSequence<MinimalSequence<LifetimeTracked>, LifetimeTracked> in
33+
MinimalSequence(elements: elements).lazy.map { $0 }
34+
},
35+
wrapValue: { (element: OpaqueValue<Int>) in
36+
LifetimeTracked(element.value, identity: element.identity)
37+
},
38+
extractValue: { (element: LifetimeTracked) in
39+
OpaqueValue(element.value, identity: element.identity)
40+
},
41+
makeSequenceOfEquatable: { (elements: [LifetimeTracked]) -> LazyMapSequence<MinimalSequence<LifetimeTracked>, LifetimeTracked> in
42+
MinimalSequence(elements: elements).lazy.map { $0 }
43+
},
44+
wrapValueIntoEquatable: { (element: MinimalEquatableValue) in
45+
LifetimeTracked(element.value, identity: element.identity)
46+
},
47+
extractValueFromEquatable: { (element: LifetimeTracked) in
48+
MinimalEquatableValue(element.value, identity: element.identity)
49+
}
50+
)
51+
52+
// Test sequence instances and iterators.
53+
CollectionTests.test("LazyMapCollection instances (Sequence)") {
54+
do {
55+
let expected = ["convent", "conform", "constrict", "condone"]
56+
let base = ["vent", "form", "strict", "done"]
57+
checkSequence(
58+
expected,
59+
MinimalSequence(elements: base).lazy.map { "con" + $0 })
60+
}
61+
do {
62+
let expected = [1, 4, 9, 16, 25, 36, 49, 64]
63+
let base = [1, 2, 3, 4, 5, 6, 7, 8]
64+
checkSequence(
65+
expected,
66+
MinimalSequence(elements: base).lazy.map { $0 * $0 })
67+
}
68+
}
69+
70+
runAllTests()
71+

0 commit comments

Comments
 (0)