EventLoopFuture: more tests for andAll/whenAllComplete (#1297)

Motivation: andAllComplete and whenAllComplete weren't very well tested but have fairly complex code. Modifications: - add more tests - move two tests that were in the wrong file Result: better test coverage
apple · Dec 9, 2019 · e0757ea · e0757ea
1 parent e208ab9
commit e0757ea
Show file tree

Hide file tree

Showing 4 changed files with 134 additions and 28 deletions.
diff --git a/Tests/NIOTests/EventLoopFutureTest+XCTest.swift b/Tests/NIOTests/EventLoopFutureTest+XCTest.swift
@@ -77,6 +77,12 @@ extension EventLoopFutureTest {
                 ("testPromiseCompletedWithFailedFuture", testPromiseCompletedWithFailedFuture),
                 ("testPromiseCompletedWithSuccessfulResult", testPromiseCompletedWithSuccessfulResult),
                 ("testPromiseCompletedWithFailedResult", testPromiseCompletedWithFailedResult),
+                ("testAndAllCompleteWithZeroFutures", testAndAllCompleteWithZeroFutures),
+                ("testAndAllSucceedWithZeroFutures", testAndAllSucceedWithZeroFutures),
+                ("testAndAllCompleteWithPreSucceededFutures", testAndAllCompleteWithPreSucceededFutures),
+                ("testAndAllCompleteWithPreFailedFutures", testAndAllCompleteWithPreFailedFutures),
+                ("testAndAllCompleteWithMixOfPreSuccededAndNotYetCompletedFutures", testAndAllCompleteWithMixOfPreSuccededAndNotYetCompletedFutures),
+                ("testWhenAllCompleteWithMixOfPreSuccededAndNotYetCompletedFutures", testWhenAllCompleteWithMixOfPreSuccededAndNotYetCompletedFutures),
            ]
    }
 }

diff --git a/Tests/NIOTests/EventLoopFutureTest.swift b/Tests/NIOTests/EventLoopFutureTest.swift
@@ -1112,4 +1112,132 @@ class EventLoopFutureTest : XCTestCase {
             XCTAssert(type(of: error) == EventLoopFutureTestError.self)
         }
     }
+
+    func testAndAllCompleteWithZeroFutures() {
+        let eventLoop = EmbeddedEventLoop()
+        let done = DispatchWorkItem {}
+        EventLoopFuture<Void>.andAllComplete([], on: eventLoop).whenComplete { (result: Result<Void, Error>) in
+            _ = result.mapError { error -> Error in
+                XCTFail("unexpected error \(error)")
+                return error
+            }
+            done.perform()
+        }
+        done.wait()
+    }
+
+    func testAndAllSucceedWithZeroFutures() {
+        let eventLoop = EmbeddedEventLoop()
+        let done = DispatchWorkItem {}
+        EventLoopFuture<Void>.andAllSucceed([], on: eventLoop).whenComplete { result in
+            _ = result.mapError { error -> Error in
+                XCTFail("unexpected error \(error)")
+                return error
+            }
+            done.perform()
+        }
+        done.wait()
+    }
+
+    func testAndAllCompleteWithPreSucceededFutures() {
+        let eventLoop = EmbeddedEventLoop()
+        let succeeded = eventLoop.makeSucceededFuture(())
+
+        for i in 0..<10 {
+            XCTAssertNoThrow(try EventLoopFuture<Void>.andAllComplete(Array(repeating: succeeded, count: i),
+                                                                      on: eventLoop).wait())
+        }
+    }
+
+    func testAndAllCompleteWithPreFailedFutures() {
+        struct Dummy: Error {}
+        let eventLoop = EmbeddedEventLoop()
+        let failed: EventLoopFuture<Void> = eventLoop.makeFailedFuture(Dummy())
+
+        for i in 0..<10 {
+            XCTAssertNoThrow(try EventLoopFuture<Void>.andAllComplete(Array(repeating: failed, count: i),
+                                                                      on: eventLoop).wait())
+        }
+    }
+
+    func testAndAllCompleteWithMixOfPreSuccededAndNotYetCompletedFutures() {
+        struct Dummy: Error {}
+        let eventLoop = EmbeddedEventLoop()
+        let succeeded = eventLoop.makeSucceededFuture(())
+        let incompletes = [eventLoop.makePromise(of: Void.self), eventLoop.makePromise(of: Void.self),
+                           eventLoop.makePromise(of: Void.self), eventLoop.makePromise(of: Void.self),
+                           eventLoop.makePromise(of: Void.self)]
+        var futures: [EventLoopFuture<Void>] = []
+
+        for i in 0..<10 {
+            if i % 2 == 0 {
+                futures.append(succeeded)
+            } else {
+                futures.append(incompletes[i/2].futureResult)
+            }
+        }
+
+        let overall = EventLoopFuture<Void>.andAllComplete(futures, on: eventLoop)
+        XCTAssertFalse(overall.isFulfilled)
+        for (idx, incomplete) in incompletes.enumerated() {
+            XCTAssertFalse(overall.isFulfilled)
+            if idx % 2 == 0 {
+                incomplete.succeed(())
+            } else {
+                incomplete.fail(Dummy())
+            }
+        }
+        XCTAssertNoThrow(try overall.wait())
+    }
+
+    func testWhenAllCompleteWithMixOfPreSuccededAndNotYetCompletedFutures() {
+        struct Dummy: Error {}
+        let eventLoop = EmbeddedEventLoop()
+        let succeeded = eventLoop.makeSucceededFuture(())
+        let incompletes = [eventLoop.makePromise(of: Void.self), eventLoop.makePromise(of: Void.self),
+                           eventLoop.makePromise(of: Void.self), eventLoop.makePromise(of: Void.self),
+                           eventLoop.makePromise(of: Void.self)]
+        var futures: [EventLoopFuture<Void>] = []
+
+        for i in 0..<10 {
+            if i % 2 == 0 {
+                futures.append(succeeded)
+            } else {
+                futures.append(incompletes[i/2].futureResult)
+            }
+        }
+
+        let overall = EventLoopFuture<Void>.whenAllComplete(futures, on: eventLoop)
+        XCTAssertFalse(overall.isFulfilled)
+        for (idx, incomplete) in incompletes.enumerated() {
+            XCTAssertFalse(overall.isFulfilled)
+            if idx % 2 == 0 {
+                incomplete.succeed(())
+            } else {
+                incomplete.fail(Dummy())
+            }
+        }
+        let expected: [Result<Void, Error>] = [.success(()), .success(()),
+                                               .success(()), .failure(Dummy()),
+                                               .success(()), .success(()),
+                                               .success(()), .failure(Dummy()),
+                                               .success(()), .success(())]
+        func assertIsEqual(_ expecteds: [Result<Void, Error>], _ actuals: [Result<Void, Error>]) {
+            XCTAssertEqual(expecteds.count, actuals.count, "counts not equal")
+            for i in expecteds.indices {
+                let expected = expecteds[i]
+                let actual = actuals[i]
+                switch (expected, actual) {
+                case (.success(()), .success(())):
+                    ()
+                case (.failure(let le), .failure(let re)):
+                    XCTAssert(le is Dummy)
+                    XCTAssert(re is Dummy)
+                default:
+                    XCTFail("\(expecteds) and \(actuals) not equal")
+                }
+            }
+        }
+        XCTAssertNoThrow(assertIsEqual(expected, try overall.wait()))
+    }
 }
diff --git a/Tests/NIOTests/EventLoopTest+XCTest.swift b/Tests/NIOTests/EventLoopTest+XCTest.swift
@@ -51,8 +51,6 @@ extension EventLoopTest {
                 ("testRepeatedTaskThatIsImmediatelyCancelledNotifies", testRepeatedTaskThatIsImmediatelyCancelledNotifies),
                 ("testRepeatedTaskThatIsCancelledAfterRunningAtLeastTwiceNotifies", testRepeatedTaskThatIsCancelledAfterRunningAtLeastTwiceNotifies),
                 ("testRepeatedTaskThatCancelsItselfNotifiesOnlyWhenFinished", testRepeatedTaskThatCancelsItselfNotifiesOnlyWhenFinished),
-                ("testAndAllCompleteWithZeroFutures", testAndAllCompleteWithZeroFutures),
-                ("testAndAllSucceedWithZeroFutures", testAndAllSucceedWithZeroFutures),
                 ("testCancelledScheduledTasksDoNotHoldOnToRunClosure", testCancelledScheduledTasksDoNotHoldOnToRunClosure),
                 ("testIllegalCloseOfEventLoopFails", testIllegalCloseOfEventLoopFails),
                 ("testSubtractingDeadlineFromPastAndFuturesDeadlinesWorks", testSubtractingDeadlineFromPastAndFuturesDeadlinesWorks),

diff --git a/Tests/NIOTests/EventLoopTest.swift b/Tests/NIOTests/EventLoopTest.swift
@@ -738,32 +738,6 @@ public final class EventLoopTest : XCTestCase {
         XCTAssertEqual(XCTWaiter.wait(for: [expect1, expect2], timeout: 0.5), .completed)
     }
 
-    func testAndAllCompleteWithZeroFutures() {
-        let eventLoop = EmbeddedEventLoop()
-        let done = DispatchWorkItem {}
-        EventLoopFuture<Void>.andAllComplete([], on: eventLoop).whenComplete { (result: Result<Void, Error>) in
-            _ = result.mapError { error -> Error in
-                XCTFail("unexpected error \(error)")
-                return error
-            }
-            done.perform()
-        }
-        done.wait()
-    }
-
-    func testAndAllSucceedWithZeroFutures() {
-        let eventLoop = EmbeddedEventLoop()
-        let done = DispatchWorkItem {}
-        EventLoopFuture<Void>.andAllSucceed([], on: eventLoop).whenComplete { result in
-            _ = result.mapError { error -> Error in
-                XCTFail("unexpected error \(error)")
-                return error
-            }
-            done.perform()
-        }
-        done.wait()
-    }
-
     func testCancelledScheduledTasksDoNotHoldOnToRunClosure() {
         let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
         defer {