     }
 
     func testThatTaskWrappingFilledIsDeterminate() {
-        let d = Deferred<Task<Int>.Result>.init(value: .Success(42))
-        let task = Task(d, cancellation: {})
+        let d = Deferred<Task<Int>.Result>(value: .Success(42))
+        let task = Task(d)
 
         XCTAssertFalse(task.progress.indeterminate)
     }
 
-    func testThatMapExtendsParentFractions() {
-        let beforeTask: Task<Int> = Task(value: 42)
-        XCTAssertEqualWithAccuracy(beforeTask.progress.fractionCompleted, 1, accuracy: 0.001)
-
-        let afterTask = beforeTask.map { $0 * 2 }
-        _ = expectationForPredicate(NSPredicate(block: {
-            abs(($0.0 as! NSProgress).fractionCompleted.distanceTo(1)) <= 0.0001
-        }), evaluatedWithObject: afterTask.progress, handler: nil)
-
-        waitForExpectationsWithTimeout(TestTimeout, handler: nil)
-    }
-
-    func testThatFlatMapExtendsParentFractions() {
-        let beforeTask: Task<Int> = Task(value: 42)
-        XCTAssertEqualWithAccuracy(beforeTask.progress.fractionCompleted, 1, accuracy: 0.001)
-
-        let afterTask = beforeTask.flatMap { (before) -> Task<Int> in
-            let d = Deferred<Task<Int>.Result>()
-            let task = Task(d, cancellation: nil)
-            afterDelay(0.5, perform: {
-                d.succeed(before * 2)
-            })
-            return task
-        }
-        XCTAssertNotEqualWithAccuracy(afterTask.progress.fractionCompleted, 1, 0.001)
-
-        _ = expectationForPredicate(NSPredicate(block: {
-            abs(($0.0 as! NSProgress).fractionCompleted.distanceTo(1)) <= 0.0001
-        }), evaluatedWithObject: afterTask.progress, handler: nil)
-
+    func testThatMapIncrementsParentProgressFraction() {
+        let task = anyFinishedTask.map { $0 * 2 }
+        _ = expectationForPredicate(NSPredicate(format: "fractionCompleted == 1"), evaluatedWithObject: task.progress, handler: nil)
+        waitForExpectationsWithTimeout(TestTimeout, handler: nil)
+    }
+
+    func testThatFlatMapIncrementsParentProgressFraction() {
+        let task = anyFinishedTask.flatMap(contrivedNextTask)
+        XCTAssertNotEqual(task.progress.fractionCompleted, 1)
+
+        _ = expectationForPredicate(NSPredicate(format: "fractionCompleted == 1"), evaluatedWithObject: task.progress, handler: nil)
         waitForExpectationsWithTimeout(TestTimeout, handler: nil)
     }
 

    }

    func testUponFailure() {
        let d = Deferred<Task<Int>.Result>()
        let task = Task(d, cancellation: {})
        let expectation = expectationWithDescription("upon is called")

        task.uponSuccess(impossible)

    }

    func testThatThrowingMapSubstitutesWithError() {
        let expectation = expectationWithDescription("mapped filled with error")
        let task: Task<String> = anyFinishedTask.map(upon: queue) { _ in
            self.assertOnQueue()
            throw Error.Second
        }

        task.upon {
            XCTAssertEqual($0.error as? Error, .Second)
            expectation.fulfill()
        }

        waitForExpectationsWithTimeout(TestTimeout, handler: nil)
    }

    func testThatFlatMapForwardsCancellationToSubsequentTask() {
        let expectation = expectationWithDescription("flatMapped task is cancelled")
        let task = anyFinishedTask.flatMap(upon: queue) { _ -> Task<String> in
            self.assertOnQueue()
            return Task(future: Future(), cancellation: expectation.fulfill)
        }

        task.cancel()

        waitForExpectationsWithTimeout(TestTimeout, handler: nil)
    }

    func testThatThrowingFlatMapSubstitutesWithError() {
        let expectation = expectationWithDescription("flatMapped task is cancelled")
        let task = anyFinishedTask.flatMap(upon: queue) { _ -> Task<String> in
            throw Error.Second
        }

        task.uponFailure {
            XCTAssertEqual($0 as? Error, .Second)
            expectation.fulfill()
        }

        waitForExpectationsWithTimeout(TestTimeout, handler: nil)
    }

    func testThatRecoverMapsFailures() {
        let expectation = expectationWithDescription("mapped filled with same error")
        let task: Task<Int> = anyFailedTask.recover(upon: queue) { _ in
            self.assertOnQueue()
            return 42
        }

        task.upon {
            XCTAssertEqual($0.value, 42)
            expectation.fulfill()
        }

        waitForExpectationsWithTimeout(TestTimeout, handler: nil)
