 				expect(signal).to(beNil())
 			}
 
+			it("should deallocate after interrupting") {
+				weak var signal: Signal<AnyObject, NoError>? = Signal { observer in
+					testScheduler.schedule {
+						sendInterrupted(observer)
+					}
+
+					return nil
+				}
+
+				var interrupted = false
+				signal?.observe(interrupted: { interrupted = true })
+
+				expect(interrupted).to(beFalsy())
+				expect(signal).toNot(beNil())
+
+				testScheduler.run()
+
+				expect(interrupted).to(beTruthy())
+				expect(signal).to(beNil())
+			}
+
 			it("should forward events to observers") {
 				let numbers = [ 1, 2, 5 ]
 				

				expect(testStr).to(beNil())
			}

			it("should release observer after disposal") {
				weak var testStr: NSMutableString?
				var disposable: Disposable!
				let signalProducer = SignalProducer<Int, NoError>() { sink, producerDisposable -> () in
					sendNext(sink, 1)
					sendNext(sink, 2)
				}

				let test: () -> () = {
					var innerStr: NSMutableString = NSMutableString()
					disposable = signalProducer.start(next: { value in
						innerStr.appendString("\(value)")
					})
					testStr = innerStr
				}
				test()

				expect(testStr).to(equal("12"))

				disposable.dispose()
//				expect(testStr).to(beNil())
			}
		}


				test()
				
				expect(weakSignal).toNot(beNil())

				testScheduler.run()
				expect(weakSignal).to(beNil())
			}

			it("should deallocate after interrupting") {
				let testScheduler = TestScheduler()
				weak var weakSignal: Signal<(), NoError>?

				let test: () -> () = {
					let (signal, observer) = Signal<(), NoError>.pipe()
					weakSignal = signal

					testScheduler.schedule {
						sendInterrupted(observer)
					}
				}

				test()
				expect(weakSignal).toNot(beNil())

				testScheduler.run()
				expect(weakSignal).to(beNil())
			}
