Merge pull request #643 from ReactiveCocoa/anders/fix-typo

mdiep · web-flow · commit a829d1c1ab8c · 2018-06-11T07:38:25.000-07:00
Rewrite names of a few test case. Disable four test cases.
diff --git a/Sources/Flatten.swift b/Sources/Flatten.swift
@@ -436,7 +436,7 @@ extension SignalProducer {
 	///   - previous: A producer to start before `self`.
 	///
 	/// - returns: A signal producer that, when started, first emits values from
-    ///            `previous` producer and then from `self`.
+	///            `previous` producer and then from `self`.
 	public func prefix<Previous: SignalProducerConvertible>(_ previous: Previous) -> SignalProducer<Value, Error> where Previous.Value == Value, Previous.Error == Error {
 		return prefix(previous.producer)
 	}
diff --git a/Tests/ReactiveSwiftTests/FlattenSpec.swift b/Tests/ReactiveSwiftTests/FlattenSpec.swift
@@ -645,22 +645,34 @@ class FlattenSpec: QuickSpec {
 					.flatMap(.latest) { _ in Property(value: 0) }
 			}
 
-			it("sould available to use contextual lookup for flatMap arbitrary error signal to arbitrary error signal") {
+			it("should be able to fallback to SignalProducer for contextual lookups with explicit inner value and error type parameters, given an upstream of arbitrary error type") {
 				_ = Signal<Int, TestError>.empty
 					.flatMap(.latest) { _ in .init(result: Result<Int, TestError>(error: .default)) }
 			}
 
-			it("sould available to use contextual lookup for flatMap NoError signal to NoError signal") {
+			it("should be able to fallback to SignalProducer for contextual lookups with implicit error type parameter") {
 				_ = Signal<Int, NoError>.empty
 					.flatMap(.latest) { _ in .init(value: 0) }
 			}
 
-			it("sould available to use contextual lookup for flatMap arbitrary error signal and NoError signal") {
+			it("should be able to fallback to SignalProducer for contextual lookups with implicit error type parameter") {
 				_ = Signal<Int, TestError>.empty
 					.flatMap(.latest) { _ in .init(value: 0) }
 			}
 
-			it("sould available to use contextual lookup for flatMap NoError signal to arbitrary error signal") {
+// NOTE: These test cases were disabled as the Swift 4.2 type checker apparently
+// cannot infer the type paramaters when both are absent.
+//			it("should be able to fallback to SignalProducer for contextual lookups without explicit inner value and error type parameters") {
+//				_ = Signal<Int, NoError>.empty
+//					.flatMap(.latest) { _ in .empty }
+//			}
+//
+//			it("should be able to fallback to SignalProducer for contextual lookups without explicit inner value and error type parameters") {
+//				_ = Signal<Int, TestError>.empty
+//					.flatMap(.latest) { _ in .empty }
+//			}
+
+			it("should be able to fallback to SignalProducer for contextual lookups with explicit inner and error type parameters, given a NoError upstream") {
 				_ = Signal<Int, NoError>.empty
 					.flatMap(.latest) { _ in .init(result: Result<Int, TestError>(error: .default)) }
 			}
@@ -835,22 +847,34 @@ class FlattenSpec: QuickSpec {
 					.flatMap(.latest) { _ in Property(value: 0) }
 			}
 
-			it("sould available to use contextual lookup for flatMap arbitrary error signal to arbitrary error signal") {
+			it("should be able to fallback to SignalProducer for contextual lookups with explicit inner value and error type parameters, given an upstream of arbitrary error type") {
 				_ = SignalProducer<Int, TestError>.empty
 					.flatMap(.latest) { _ in .init(error: .default) } as SignalProducer<Int, TestError>
 			}
 
-			it("sould available to use contextual lookup for flatMap NoError signal to NoError signal") {
+			it("should be able to fallback to SignalProducer for contextual lookups with implicit inner error type parameter") {
 				_ = SignalProducer<Int, NoError>.empty
 					.flatMap(.latest) { _ in .init(value: 0) }
 			}
 
-			it("sould available to use contextual lookup for flatMap arbitrary error signal to NoError signal") {
+			it("should be able to fallback to SignalProducer for contextual lookups with implicit inner error type parameter") {
 				_ = SignalProducer<Int, TestError>.empty
 					.flatMap(.latest) { _ in .init(value: 0) }
 			}
 
-			it("sould available to use contextual lookup for flatMap NoError signal to arbitrary error signal") {
+// NOTE: These test cases were disabled as the Swift 4.2 type checker apparently
+// cannot infer the type paramaters when both are absent.
+//			it("should be able to fallback to SignalProducer for contextual lookups without explicit inner value and error type parameters") {
+//				_ = SignalProducer<Int, NoError>.empty
+//					.flatMap(.latest) { _ in .empty }
+//			}
+//
+//			it("should be able to fallback to SignalProducer for contextual lookups without explicit inner value and error type parameters") {
+//				_ = SignalProducer<Int, TestError>.empty
+//					.flatMap(.latest) { _ in .empty }
+//			}
+
+			it("should be able to fallback to SignalProducer for contextual lookups with explicit inner and error type parameters, given a NoError upstream.") {
 				_ = SignalProducer<Int, NoError>.empty
 					.flatMap(.latest) { _ in .init(error: .default) } as SignalProducer<Int, TestError>
 			}
@@ -1139,7 +1163,7 @@ class FlattenSpec: QuickSpec {
 				expect(completed) == true
 			}
 
-			it("sould available to use contextual lookup") {
+			it("should be able to fallback to SignalProducer for contextual lookups") {
 				_ = SignalProducer<Int, NoError>.empty
 					.merge(with: .init(value: 0))
 			}
@@ -1206,7 +1230,7 @@ class FlattenSpec: QuickSpec {
 				expect(lastValue) == 3
 			}
 
-			it("sould available to use contextual lookup") {
+			it("should be able to fallback to SignalProducer for contextual lookups") {
 				_ = SignalProducer<Int, NoError>.empty
 					.prefix(.init(value: 0))
 			}
@@ -1310,7 +1334,7 @@ class FlattenSpec: QuickSpec {
 				expect(results[0].error) == .error1
 			}
 
-			it("sould available to use contextual lookup") {
+			it("should be able to fallback to SignalProducer for contextual lookups") {
 				_ = SignalProducer<Int, NoError>.empty
 					.concat(.init(value: 0))
 			}
diff --git a/Tests/ReactiveSwiftTests/PropertySpec.swift b/Tests/ReactiveSwiftTests/PropertySpec.swift
@@ -662,11 +662,11 @@ class PropertySpec: QuickSpec {
 						expect(signalInterrupted) == true
 					}
 
-					it("sould available to use contextual lookup") {
+					it("should be able to fallback to SignalProducer for contextual lookups") {
 						_ = Property(initial: 0, then: .init(value: 0))
 					}
 
-					it("sould available to use contextual lookup for optional value") {
+					it("should be able to fallback to SignalProducer for contextual lookups when an optional value type parameter is involved") {
 						_ = Property(initial: Optional(0), then: .init(value: 0))
 					}
 				}
diff --git a/Tests/ReactiveSwiftTests/SignalProducerLiftingSpec.swift b/Tests/ReactiveSwiftTests/SignalProducerLiftingSpec.swift
@@ -723,7 +723,7 @@ class SignalProducerLiftingSpec: QuickSpec {
 				expect(lastValue) == 0
 			}
 
-			it("sould available to use contextual lookup") {
+			it("should be able to fallback to SignalProducer for contextual lookups") {
 				_ = SignalProducer<Int, NoError>.empty
 					.skip(until: .init(value: ()))
 			}
@@ -1023,7 +1023,7 @@ class SignalProducerLiftingSpec: QuickSpec {
 				expect(lastValue).to(beNil())
 			}
 
-			it("sould available to use contextual lookup") {
+			it("should be able to fallback to SignalProducer for contextual lookups") {
 				_ = SignalProducer<Int, NoError>.empty
 					.take(until: .init(value: ()))
 			}
@@ -1088,7 +1088,7 @@ class SignalProducerLiftingSpec: QuickSpec {
 				expect(completed) == true
 			}
 
-			it("sould available to use contextual lookup") {
+			it("should be able to fallback to SignalProducer for contextual lookups") {
 				_ = SignalProducer<Int, NoError>.empty
 					.take(untilReplacement: .init(value: 0))
 			}
@@ -1434,7 +1434,7 @@ class SignalProducerLiftingSpec: QuickSpec {
 				expect(valueReceived) == "1a"
 			}
 
-			it("sould available to use contextual lookup") {
+			it("should be able to fallback to SignalProducer for contextual lookups") {
 				_ = SignalProducer<Int, NoError>.empty
 					.sample(with: .init(value: 0))
 			}
@@ -1547,7 +1547,7 @@ class SignalProducerLiftingSpec: QuickSpec {
 				}
 			}
 
-			it("sould available to use contextual lookup") {
+			it("should be able to fallback to SignalProducer for contextual lookups") {
 				_ = SignalProducer<Int, NoError>.empty
 					.sample(on: .init(value: ()))
 			}
@@ -1684,7 +1684,7 @@ class SignalProducerLiftingSpec: QuickSpec {
 				expect(event).to(beNil())
 			}
 
-			it("sould available to use contextual lookup") {
+			it("should be able to fallback to SignalProducer for contextual lookups") {
 				_ = SignalProducer<Int, NoError>.empty
 					.withLatest(from: .init(value: 0))
 			}
@@ -1731,7 +1731,7 @@ class SignalProducerLiftingSpec: QuickSpec {
 				expect(completed) == true
 			}
 
-			it("sould available to use contextual lookup") {
+			it("should be able to fallback to SignalProducer for contextual lookups") {
 				_ = SignalProducer<Int, NoError>.empty
 					.combineLatest(with: .init(value: 0))
 			}
@@ -1803,7 +1803,7 @@ class SignalProducerLiftingSpec: QuickSpec {
 				expect(result) == [ "0foo" ]
 			}
 
-			it("sould available to use contextual lookup") {
+			it("should be able to fallback to SignalProducer for contextual lookups") {
 				_ = SignalProducer<Int, NoError>.empty
 					.zip(with: .init(value: 0))
 			}
diff --git a/Tests/ReactiveSwiftTests/SignalProducerSpec.swift b/Tests/ReactiveSwiftTests/SignalProducerSpec.swift
@@ -1311,7 +1311,7 @@ class SignalProducerSpec: QuickSpec {
 				expect(disposed) == true
 			}
 
-			it("sould available to use contextual lookup") {
+			it("should be able to fallback to SignalProducer for contextual lookups") {
 				_ = SignalProducer<Int, TestError>.empty
 					.flatMapError { _ in .init(value: 0) }
 			}
@@ -2317,32 +2317,32 @@ class SignalProducerSpec: QuickSpec {
 				expect(type(of: h)) == SignalProducer<Double, TestError>.self
 			}
 
-			it("sould available to use contextual lookup for arbitrary error signal then same value same error signal") {
+			it("should be able to fallback to SignalProducer for contextual lookups without explicit value and error type parameters, given an upstream of arbitrary error type") {
 				_ = SignalProducer<Int, TestError>.empty
-					.then(.init(value: 0))
+					.then(.empty)
 			}
 
-			it("sould available to use contextual lookup for arbitrary error signal then other value same error signal") {
+			it("should be able to fallback to SignalProducer for contextual lookups with explicit value and error type parameters, given an upstream of arbitary error type") {
 				_ = SignalProducer<Int, TestError>.empty
 					.then(.init(result: Result<String, TestError>(value: "")))
 			}
 
-			it("sould available to use contextual lookup for arbitrary error signal then other value NoError signal") {
+			it("should be able to fallback to SignalProducer for contextual lookups without explicit error type parameter") {
 				_ = SignalProducer<Int, TestError>.empty
 					.then(.init(value: ""))
 			}
 
-			it("sould available to use contextual lookup for NoError signal then same value same error signal") {
+			it("should be able to fallback to SignalProducer for contextual lookups without explicit value and error type parameters, given a NoError upstream") {
 				_ = SignalProducer<Int, NoError>.empty
-					.then(.init(value: 0))
+					.then(.empty)
 			}
 
-			it("sould available to use contextual lookup for NoError signal then other value same error signal") {
+			it("should be able to fallback to SignalProducer for contextual lookups without explicit error type parameter") {
 				_ = SignalProducer<Int, NoError>.empty
 					.then(.init(value: ""))
 			}
 
-			it("sould available to use contextual lookup for NoError signal then other value arbitrary error signal") {
+			it("should be able to fallback to SignalProducer for contextual lookups with explicit value and error type parameters, given a NoError upstream") {
 				_ = SignalProducer<Int, NoError>.empty
 					.then(.init(result: Result<String, TestError>(value: "")))
 			}
@@ -2994,7 +2994,7 @@ class SignalProducerSpec: QuickSpec {
 				observer2.sendCompleted()
 			}
 
-			it("sould available to use contextual lookup") {
+			it("should be able to fallback to SignalProducer for contextual lookups") {
 				_ = SignalProducer<Bool, NoError>.empty
 					.and(.init(value: true))
 			}
@@ -3045,7 +3045,7 @@ class SignalProducerSpec: QuickSpec {
 				observer2.sendCompleted()
 			}
 
-			it("sould available to use contextual lookup") {
+			it("should be able to fallback to SignalProducer for contextual lookups") {
 				_ = SignalProducer<Bool, NoError>.empty
 					.or(.init(value: true))
 			}
diff --git a/Tests/ReactiveSwiftTests/SignalSpec.swift b/Tests/ReactiveSwiftTests/SignalSpec.swift
@@ -2685,7 +2685,7 @@ class SignalSpec: QuickSpec {
 				expect(event).to(beNil())
 			}
 
-			it("sould available to use contextual lookup") {
+			it("should be able to fallback to SignalProducer for contextual lookups") {
 				_ = Signal<Int, NoError>.empty
 					.withLatest(from: .init(value: 0))
 			}

Original file line number	Diff line number	Diff line change
`@@ -436,7 +436,7 @@ extension SignalProducer {`
`436`	`436`	/// - previous: A producer to start before `self`.
`437`	`437`	`///`
`438`	`438`	`/// - returns: A signal producer that, when started, first emits values from`
`439`		- /// `previous` producer and then from `self`.
	`439`	+ /// `previous` producer and then from `self`.
`440`	`440`	`public func prefix<Previous: SignalProducerConvertible>(_ previous: Previous) -> SignalProducer<Value, Error> where Previous.Value == Value, Previous.Error == Error {`
`441`	`441`	`return prefix(previous.producer)`
`442`	`442`	`}`
Original file line number	Diff line number	Diff line change
`@@ -662,11 +662,11 @@ class PropertySpec: QuickSpec {`
`662`	`662`	`expect(signalInterrupted) == true`
`663`	`663`	`}`
`664`	`664`
`665`		`- it("sould available to use contextual lookup") {`
	`665`	`+ it("should be able to fallback to SignalProducer for contextual lookups") {`
`666`	`666`	`_ = Property(initial: 0, then: .init(value: 0))`
`667`	`667`	`}`
`668`	`668`
`669`		`- it("sould available to use contextual lookup for optional value") {`
	`669`	`+ it("should be able to fallback to SignalProducer for contextual lookups when an optional value type parameter is involved") {`
`670`	`670`	`_ = Property(initial: Optional(0), then: .init(value: 0))`
`671`	`671`	`}`
`672`	`672`	`}`
Original file line number	Diff line number	Diff line change
`@@ -723,7 +723,7 @@ class SignalProducerLiftingSpec: QuickSpec {`
`723`	`723`	`expect(lastValue) == 0`
`724`	`724`	`}`
`725`	`725`
`726`		`- it("sould available to use contextual lookup") {`
	`726`	`+ it("should be able to fallback to SignalProducer for contextual lookups") {`
`727`	`727`	`_ = SignalProducer<Int, NoError>.empty`
`728`	`728`	`.skip(until: .init(value: ()))`
`729`	`729`	`}`
`@@ -1023,7 +1023,7 @@ class SignalProducerLiftingSpec: QuickSpec {`
`1023`	`1023`	`expect(lastValue).to(beNil())`
`1024`	`1024`	`}`
`1025`	`1025`
`1026`		`- it("sould available to use contextual lookup") {`
	`1026`	`+ it("should be able to fallback to SignalProducer for contextual lookups") {`
`1027`	`1027`	`_ = SignalProducer<Int, NoError>.empty`
`1028`	`1028`	`.take(until: .init(value: ()))`
`1029`	`1029`	`}`
`@@ -1088,7 +1088,7 @@ class SignalProducerLiftingSpec: QuickSpec {`
`1088`	`1088`	`expect(completed) == true`
`1089`	`1089`	`}`
`1090`	`1090`
`1091`		`- it("sould available to use contextual lookup") {`
	`1091`	`+ it("should be able to fallback to SignalProducer for contextual lookups") {`
`1092`	`1092`	`_ = SignalProducer<Int, NoError>.empty`
`1093`	`1093`	`.take(untilReplacement: .init(value: 0))`
`1094`	`1094`	`}`
`@@ -1434,7 +1434,7 @@ class SignalProducerLiftingSpec: QuickSpec {`
`1434`	`1434`	`expect(valueReceived) == "1a"`
`1435`	`1435`	`}`
`1436`	`1436`
`1437`		`- it("sould available to use contextual lookup") {`
	`1437`	`+ it("should be able to fallback to SignalProducer for contextual lookups") {`
`1438`	`1438`	`_ = SignalProducer<Int, NoError>.empty`
`1439`	`1439`	`.sample(with: .init(value: 0))`
`1440`	`1440`	`}`
`@@ -1547,7 +1547,7 @@ class SignalProducerLiftingSpec: QuickSpec {`
`1547`	`1547`	`}`
`1548`	`1548`	`}`
`1549`	`1549`
`1550`		`- it("sould available to use contextual lookup") {`
	`1550`	`+ it("should be able to fallback to SignalProducer for contextual lookups") {`
`1551`	`1551`	`_ = SignalProducer<Int, NoError>.empty`
`1552`	`1552`	`.sample(on: .init(value: ()))`
`1553`	`1553`	`}`
`@@ -1684,7 +1684,7 @@ class SignalProducerLiftingSpec: QuickSpec {`
`1684`	`1684`	`expect(event).to(beNil())`
`1685`	`1685`	`}`
`1686`	`1686`
`1687`		`- it("sould available to use contextual lookup") {`
	`1687`	`+ it("should be able to fallback to SignalProducer for contextual lookups") {`
`1688`	`1688`	`_ = SignalProducer<Int, NoError>.empty`
`1689`	`1689`	`.withLatest(from: .init(value: 0))`
`1690`	`1690`	`}`
`@@ -1731,7 +1731,7 @@ class SignalProducerLiftingSpec: QuickSpec {`
`1731`	`1731`	`expect(completed) == true`
`1732`	`1732`	`}`
`1733`	`1733`
`1734`		`- it("sould available to use contextual lookup") {`
	`1734`	`+ it("should be able to fallback to SignalProducer for contextual lookups") {`
`1735`	`1735`	`_ = SignalProducer<Int, NoError>.empty`
`1736`	`1736`	`.combineLatest(with: .init(value: 0))`
`1737`	`1737`	`}`
`@@ -1803,7 +1803,7 @@ class SignalProducerLiftingSpec: QuickSpec {`
`1803`	`1803`	`expect(result) == [ "0foo" ]`
`1804`	`1804`	`}`
`1805`	`1805`
`1806`		`- it("sould available to use contextual lookup") {`
	`1806`	`+ it("should be able to fallback to SignalProducer for contextual lookups") {`
`1807`	`1807`	`_ = SignalProducer<Int, NoError>.empty`
`1808`	`1808`	`.zip(with: .init(value: 0))`
`1809`	`1809`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1311,7 +1311,7 @@ class SignalProducerSpec: QuickSpec {`
`1311`	`1311`	`expect(disposed) == true`
`1312`	`1312`	`}`
`1313`	`1313`
`1314`		`- it("sould available to use contextual lookup") {`
	`1314`	`+ it("should be able to fallback to SignalProducer for contextual lookups") {`
`1315`	`1315`	`_ = SignalProducer<Int, TestError>.empty`
`1316`	`1316`	`.flatMapError { _ in .init(value: 0) }`
`1317`	`1317`	`}`
`@@ -2317,32 +2317,32 @@ class SignalProducerSpec: QuickSpec {`
`2317`	`2317`	`expect(type(of: h)) == SignalProducer<Double, TestError>.self`
`2318`	`2318`	`}`
`2319`	`2319`
`2320`		`- it("sould available to use contextual lookup for arbitrary error signal then same value same error signal") {`
	`2320`	`+ it("should be able to fallback to SignalProducer for contextual lookups without explicit value and error type parameters, given an upstream of arbitrary error type") {`
`2321`	`2321`	`_ = SignalProducer<Int, TestError>.empty`
`2322`		`- .then(.init(value: 0))`
	`2322`	`+ .then(.empty)`
`2323`	`2323`	`}`
`2324`	`2324`
`2325`		`- it("sould available to use contextual lookup for arbitrary error signal then other value same error signal") {`
	`2325`	`+ it("should be able to fallback to SignalProducer for contextual lookups with explicit value and error type parameters, given an upstream of arbitary error type") {`
`2326`	`2326`	`_ = SignalProducer<Int, TestError>.empty`
`2327`	`2327`	`.then(.init(result: Result<String, TestError>(value: "")))`
`2328`	`2328`	`}`
`2329`	`2329`
`2330`		`- it("sould available to use contextual lookup for arbitrary error signal then other value NoError signal") {`
	`2330`	`+ it("should be able to fallback to SignalProducer for contextual lookups without explicit error type parameter") {`
`2331`	`2331`	`_ = SignalProducer<Int, TestError>.empty`
`2332`	`2332`	`.then(.init(value: ""))`
`2333`	`2333`	`}`
`2334`	`2334`
`2335`		`- it("sould available to use contextual lookup for NoError signal then same value same error signal") {`
	`2335`	`+ it("should be able to fallback to SignalProducer for contextual lookups without explicit value and error type parameters, given a NoError upstream") {`
`2336`	`2336`	`_ = SignalProducer<Int, NoError>.empty`
`2337`		`- .then(.init(value: 0))`
	`2337`	`+ .then(.empty)`
`2338`	`2338`	`}`
`2339`	`2339`
`2340`		`- it("sould available to use contextual lookup for NoError signal then other value same error signal") {`
	`2340`	`+ it("should be able to fallback to SignalProducer for contextual lookups without explicit error type parameter") {`
`2341`	`2341`	`_ = SignalProducer<Int, NoError>.empty`
`2342`	`2342`	`.then(.init(value: ""))`
`2343`	`2343`	`}`
`2344`	`2344`
`2345`		`- it("sould available to use contextual lookup for NoError signal then other value arbitrary error signal") {`
	`2345`	`+ it("should be able to fallback to SignalProducer for contextual lookups with explicit value and error type parameters, given a NoError upstream") {`
`2346`	`2346`	`_ = SignalProducer<Int, NoError>.empty`
`2347`	`2347`	`.then(.init(result: Result<String, TestError>(value: "")))`
`2348`	`2348`	`}`
`@@ -2994,7 +2994,7 @@ class SignalProducerSpec: QuickSpec {`
`2994`	`2994`	`observer2.sendCompleted()`
`2995`	`2995`	`}`
`2996`	`2996`
`2997`		`- it("sould available to use contextual lookup") {`
	`2997`	`+ it("should be able to fallback to SignalProducer for contextual lookups") {`
`2998`	`2998`	`_ = SignalProducer<Bool, NoError>.empty`
`2999`	`2999`	`.and(.init(value: true))`
`3000`	`3000`	`}`
`@@ -3045,7 +3045,7 @@ class SignalProducerSpec: QuickSpec {`
`3045`	`3045`	`observer2.sendCompleted()`
`3046`	`3046`	`}`
`3047`	`3047`
`3048`		`- it("sould available to use contextual lookup") {`
	`3048`	`+ it("should be able to fallback to SignalProducer for contextual lookups") {`
`3049`	`3049`	`_ = SignalProducer<Bool, NoError>.empty`
`3050`	`3050`	`.or(.init(value: true))`
`3051`	`3051`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2685,7 +2685,7 @@ class SignalSpec: QuickSpec {`
`2685`	`2685`	`expect(event).to(beNil())`
`2686`	`2686`	`}`
`2687`	`2687`
`2688`		`- it("sould available to use contextual lookup") {`
	`2688`	`+ it("should be able to fallback to SignalProducer for contextual lookups") {`
`2689`	`2689`	`_ = Signal<Int, NoError>.empty`
`2690`	`2690`	`.withLatest(from: .init(value: 0))`
`2691`	`2691`	`}`