 			}
 
 			it("should release signal observers when given disposable is disposed") {
-				var dispose: () -> () = {}
-				let producer = SignalProducer<Int, NoError> { _, disposable in
-					dispose = { _ in disposable.dispose() }
+				var disposable: Disposable!
+				let producer = SignalProducer<Int, NoError> { _, innerDisposable in
+					disposable = innerDisposable
 				}
 
 				weak var testSink: TestSink?


				expect(testSink).toNot(beNil())

				dispose()
				expect(testSink).to(beNil())
			}

			it("should dispose of added disposables upon completion") {
				let addedDisposable = SimpleDisposable()
				var test: () -> () = { }

				let producer = SignalProducer<(), NoError>() { observer, disposable in
					disposable.addDisposable(addedDisposable)
					test = { _ in sendCompleted(observer) }
				}

				producer.start()
				expect(addedDisposable.disposed).to(beFalsy())

				test()
				expect(addedDisposable.disposed).to(beTruthy())
			}

			it("should dispose of added disposables upon error") {
				let addedDisposable = SimpleDisposable()
				var test: () -> () = { }

				let producer = SignalProducer<(), TestError>() { observer, disposable in
					disposable.addDisposable(addedDisposable)
					test = { _ in sendError(observer, .Default) }
				}

				producer.start()
				expect(addedDisposable.disposed).to(beFalsy())

				test()
				expect(addedDisposable.disposed).to(beTruthy())
			}

			it("should dispose of added disposables upon interruption") {
				let addedDisposable = SimpleDisposable()
				var test: () -> () = { }

				let producer = SignalProducer<(), NoError>() { observer, disposable in
					disposable.addDisposable(addedDisposable)
					test = { _ in sendInterrupted(observer) }
				}

				producer.start()
				expect(addedDisposable.disposed).to(beFalsy())

				test()
				expect(addedDisposable.disposed).to(beTruthy())
			}



			it("should dispose of added disposables upon completion") {
				let addedDisposable = SimpleDisposable()
				var sink: Signal<Int, TestError>.Observer!

				let producer = SignalProducer<Int, TestError>() { observer, disposable in
					disposable.addDisposable(addedDisposable)
					sink = observer
				}

				producer |> startWithSignal { _ in }
				expect(addedDisposable.disposed).to(beFalsy())

				sendCompleted(sink)
				expect(addedDisposable.disposed).to(beTruthy())
			}

			it("should dispose of added disposables upon error") {
				let addedDisposable = SimpleDisposable()
				var sink: Signal<Int, TestError>.Observer!

				let producer = SignalProducer<Int, TestError>() { observer, disposable in
					disposable.addDisposable(addedDisposable)
					sink = observer
				}

				producer |> startWithSignal { _ in }
				expect(addedDisposable.disposed).to(beFalsy())

				sendError(sink, .Default)
				expect(addedDisposable.disposed).to(beTruthy())
			}
		}
