 					sendSubsequent = { sendNext(outerSink, subsequentProducer) }
 					completeOuter = { sendCompleted(outerSink) }
 
-					concat(outerProducer).start()
+					(outerProducer |> join(.Concat)).start()
 					sendNext(outerSink, previousProducer)
 				}
 

				dispatch_group_wait(group, DISPATCH_TIME_FOREVER)
				expect(result?.value).toNot(beNil())
			}
			
			it("should return an error if one occurs") {
				let result = SignalProducer<Int, TestError>(error: .Default) |> wait
				expect(result.error).to(equal(TestError.Default))

			it("should forward an error from an inner signal") {
				let inner = SignalProducer<Int, TestError>(error: .Default)
				let outer = SignalProducer<SignalProducer<Int, TestError>, TestError>(value: inner)
				let result = outer |> join(.SwitchToLatest) |> first

				expect(result?.error).to(equal(TestError.Default))
			}

			it("should forward an error from the outer signal") {
				let outer = SignalProducer<SignalProducer<Int, TestError>, TestError>(error: .Default)
				let result = outer |> join(.SwitchToLatest) |> first

				expect(result?.error).to(equal(TestError.Default))
			}

			it("should complete when the original and latest signals have completed") {
				let inner = SignalProducer<Int, TestError>.empty
				let outer = SignalProducer<SignalProducer<Int, TestError>, TestError>(value: inner)

				var completed = false
				(outer |> join(.SwitchToLatest)).start(completed: {
					completed = true
				})

				expect(completed).to(beTruthy())
			}

			it("should complete when the outer signal completes before sending any signals") {
				let outer = SignalProducer<SignalProducer<Int, TestError>, TestError>.empty

				var completed = false
				(outer |> join(.SwitchToLatest)).start(completed: {
					completed = true
				})

				expect(completed).to(beTruthy())
			}
		}
