             }
         }
     }
-
-    // MARK: - How Long the Whole Chain Takes
-
-    func testChain() {
-        measure {
-            var remaining = 5000
+}
+
+class FutureChainsTests: XCTestCase {
+    // Test how fast the whole chains take
+
+    func testChain_Map_FlatMap_MapError() {
+        measure {
             let expecation = self.expectation()
+            expecation.expectedFulfillmentCount = 5000
+
             for _ in 0..<5000 {
                 let future = Future<Int, Void>(value: 1)
                     .map { $0 + 1 }
                     .flatMap { Future<Int, Void>(value: $0 + 1) }
                     .mapError { $0 }
 
-                future.on(success: { _ in
-                    remaining -= 1
-                    if remaining == 0 {
-                        expecation.fulfill()
-                    }
-                })
+                future.on(success: { _ in expecation.fulfill() })
             }
             wait()
         }
     }
 
-    func testZip() {
-        measure {
-            var remaining = 5000
+    func testZipArrayOf3() {
+        measure {
             let expecation = self.expectation()
+            expecation.expectedFulfillmentCount = 5000
+
             for _ in 0..<5000 {
                 let future = Future.zip([
                     Future<Int, Void>(value: 1),

        }
    }
}

                    Future<Int, Void>(value: 4)]
                )

                future.on(success: { _ in expecation.fulfill() })
            }
            wait()
        }
    }

    func testZipArrayOf1000() {
        measure {
            let iterations = 10
            let futuresPerIteration = 1000

            let expecation = self.expectation()
            expecation.expectedFulfillmentCount = iterations

            let promises = Array(0..<iterations).map { _ in
                Array(0..<futuresPerIteration).map { _ in
                    Promise<Int, Never>()
                }
            }

            DispatchQueue.concurrentPerform(iterations: iterations) { iteration in
                let zip = Future.zip(promises[iteration].map { $0.future })
                zip.on(success: { _ in
                    expecation.fulfill()
                })
            }

            DispatchQueue.global().async {
                DispatchQueue.concurrentPerform(iterations: iterations) { iteration in
                    for promise in promises[iteration] {
                        promise.succeed(value: 1)
                    }
                }
            }

            wait()
        }
    }
}

class FutureMapPerformanceTests: XCTestCase {

    func testMap() {
        let futures = Array(0..<10000).map { _ in
            Future(value: 1)
