     }
 
     func testThatMapPassesThroughErrors() {
-        let beforeExpectation = expectationWithDescription("original task filled")
-        let beforeTask: Task<Int> = Task(error: Error.First)
-
-        let afterExpectation = expectationWithDescription("mapped filled with same error")
-        let afterTask: Task<String> = beforeTask.map(impossible)
-
-        beforeTask.upon {
+        let expectation = expectationWithDescription("mapped filled with same error")
+        let task: Task<String> = anyFailedTask.map(impossible)
+
+        task.upon {
             XCTAssertEqual($0.error as? Error, .First)
-            beforeExpectation.fulfill()
-        }
-
-        afterTask.upon {
-            XCTAssertEqual($0.error as? Error, .First)
-            afterExpectation.fulfill()
+            expectation.fulfill()
         }
 
         waitForExpectationsWithTimeout(TestTimeout, handler: nil)
     }
 
     func testThatThrowingMapSubstitutesWithError() {
-        let beforeExpectation = expectationWithDescription("original task filled")
-        let beforeTask: Task<Int> = Task(value: -1)
-
-        let afterExpectation = expectationWithDescription("mapped filled with error")
-        let afterTask: Task<String> = beforeTask.map { _ in
-            throw Error.Second
-        }
-
-        beforeTask.upon {
-            XCTAssertEqual($0.value, -1)
-            beforeExpectation.fulfill()
-        }
-
-        afterTask.upon {
+        let expectation = expectationWithDescription("mapped filled with error")
+        let task: Task<String> = anyFinishedTask.map { _ in
+            throw Error.Second
+        }
+
+        task.upon {
             XCTAssertEqual($0.error as? Error, .Second)
-            afterExpectation.fulfill()
+            expectation.fulfill()
         }
 
         waitForExpectationsWithTimeout(TestTimeout, handler: nil)
     }
 
     func testThatFlatMapForwardsCancellationToSubsequentTask() {
-        let beforeTask = Task<Int>(value: 1)
-
-        let afterExpectation = expectationWithDescription("flatMapped task is cancelled")
-        let afterTask: Task<String> = beforeTask.flatMap { _ in
-            return Task(future: Future(), cancellation: afterExpectation.fulfill)
-        }
-
-        afterTask.cancel()
+        let expectation = expectationWithDescription("flatMapped task is cancelled")
+        let task: Task<String> = anyFinishedTask.flatMap { _ in
+            return Task(future: Future(), cancellation: expectation.fulfill)
+        }
+
+        task.cancel()
 
         waitForExpectationsWithTimeout(TestTimeout, handler: nil)
     }
 
     func testThatThrowingFlatMapSubstitutesWithError() {
-        let beforeTask = Task<Int>(value: 1)
-
-        let afterExpectation = expectationWithDescription("flatMapped task is cancelled")
-        let afterTask: Task<String> = beforeTask.flatMap { _ -> Task<String> in
-            throw Error.Second
-        }
-
-        afterTask.uponFailure {
+        let expectation = expectationWithDescription("flatMapped task is cancelled")
+        let task: Task<String> = anyFinishedTask.flatMap { _ -> Task<String> in
+            throw Error.Second
+        }
+
+        task.uponFailure {
             XCTAssertEqual($0 as? Error, .Second)
-            afterExpectation.fulfill()
+            expectation.fulfill()
         }
 
         waitForExpectationsWithTimeout(TestTimeout, handler: nil)
     }
 
     func testThatRecoverPassesThroughValues() {
-        let beforeExpectation = expectationWithDescription("original task filled")
-        let beforeTask: Task<Int> = Task(value: 1)
-
-        let afterExpectation = expectationWithDescription("mapped filled with same error")
-        let afterTask: Task<Int> = beforeTask.recover(impossible)
-
-        beforeTask.upon {
-            XCTAssertEqual($0.value, 1)
-            beforeExpectation.fulfill()
-        }
-
-        afterTask.upon {
+        let expectation = expectationWithDescription("mapped filled with same error")
+        let task: Task<Int> = anyFinishedTask.recover(impossible)
+
+        task.upon {
             XCTAssertNil($0.error)
-            afterExpectation.fulfill()
+            expectation.fulfill()
         }
 
         waitForExpectationsWithTimeout(TestTimeout, handler: nil)
     }
 
     func testThatRecoverMapsFailures() {
-        let beforeExpectation = expectationWithDescription("original task filled")
-        let beforeTask: Task<Int> = Task(error: Error.First)
-
-        let afterExpectation = expectationWithDescription("mapped filled with same error")
-        let afterTask: Task<Int> = beforeTask.recover { _ in 42 }
-
-        beforeTask.upon {
-            XCTAssertEqual($0.error as? Error, .First)
-            beforeExpectation.fulfill()
-        }
-
-        afterTask.upon {
+        let expectation = expectationWithDescription("mapped filled with same error")
+        let task: Task<Int> = anyFailedTask.recover { _ in 42 }
+
+        task.upon {
             XCTAssertEqual($0.value, 42)
-            afterExpectation.fulfill()
+            expectation.fulfill()
         }
 
         waitForExpectationsWithTimeout(TestTimeout, handler: nil)

        XCTAssertEqualWithAccuracy(task.progress.fractionCompleted, 0.5, accuracy: 0.001)
    }

    func testThatTaskCreatedUnfilledIsIndeterminate() {
        let task = Task<Int>()


    }

    func testUponFailure() {
        let (d, task) = anyUnfinishedTask
        let expectation = expectationWithDescription("upon is called")

        task.uponSuccess(impossible)
