From b9fcf9962dbd093397c6ff572c665b5ead4ebf79 Mon Sep 17 00:00:00 2001 From: Eugene Kabanov Date: Thu, 9 Feb 2023 06:08:47 +0200 Subject: [PATCH] Refactor Future[T] test suite. (#359) * Refactor testfut.nim. * Fix location test lines. --- tests/testfut.nim | 770 ++++++++++++++++++++++++++++------------------ 1 file changed, 476 insertions(+), 294 deletions(-) diff --git a/tests/testfut.nim b/tests/testfut.nim index 656cacd6..23015b97 100644 --- a/tests/testfut.nim +++ b/tests/testfut.nim @@ -6,7 +6,7 @@ # Apache License, version 2.0, (LICENSE-APACHEv2) # MIT license (LICENSE-MIT) import unittest2 -import ../chronos +import ../chronos, ../chronos/unittest2/asynctests when defined(nimHasUsed): {.used.} @@ -23,67 +23,6 @@ suite "Future[T] behavior test suite": proc testFuture100(): Future[int] {.async.} = await sleepAsync(100.milliseconds) - proc testFuture4(): Future[int] {.async.} = - ## Test for not immediately completed future and timeout = -1 - result = 0 - try: - discard await wait(testFuture1(), InfiniteDuration) - result = 1 - except: - result = 0 - - if result == 0: - return -1 - - ## Test for immediately completed future and timeout = -1 - result = 0 - try: - discard await wait(testFuture2(), InfiniteDuration) - result = 2 - except: - result = 0 - - if result == 0: - return -2 - - ## Test for not immediately completed future and timeout = 0 - result = 0 - try: - discard await wait(testFuture1(), 0.milliseconds) - except AsyncTimeoutError: - result = 3 - - if result == 0: - return -3 - - ## Test for immediately completed future and timeout = 0 - result = 0 - try: - discard await wait(testFuture2(), 0.milliseconds) - result = 4 - except: - result = 0 - - if result == 0: - return -4 - - ## Test for future which cannot be completed in timeout period - result = 0 - try: - discard await wait(testFuture100(), 50.milliseconds) - except AsyncTimeoutError: - result = 5 - - if result == 0: - return -5 - - ## Test for future which will be completed before timeout exceeded. - try: - discard await wait(testFuture100(), 500.milliseconds) - result = 6 - except: - result = -6 - test "Async undefined behavior (#7758) test": var fut = testFuture1() poll() @@ -141,11 +80,70 @@ suite "Future[T] behavior test suite": fut.finished testResult == "1245" - test "wait[T]() test": - check: - waitFor(testFuture4()) == 6 + asyncTest "wait[T]() test": + block: + ## Test for not immediately completed future and timeout = -1 + let res = + try: + discard await wait(testFuture1(), InfiniteDuration) + true + except CatchableError: + false + check res + block: + ## Test for immediately completed future and timeout = -1 + let res = + try: + discard await wait(testFuture2(), InfiniteDuration) + true + except CatchableError: + false + check res + block: + ## Test for not immediately completed future and timeout = 0 + let res = + try: + discard await wait(testFuture1(), 0.milliseconds) + false + except AsyncTimeoutError: + true + except CatchableError: + false + check res - test "discard result Future[T] test": + block: + ## Test for immediately completed future and timeout = 0 + let res = + try: + discard await wait(testFuture2(), 0.milliseconds) + true + except CatchableError: + false + check res + + block: + ## Test for future which cannot be completed in timeout period + let res = + try: + discard await wait(testFuture100(), 50.milliseconds) + false + except AsyncTimeoutError: + true + except CatchableError: + false + check res + + block: + ## Test for future which will be completed before timeout exceeded. + let res = + try: + discard await wait(testFuture100(), 500.milliseconds) + true + except CatchableError: + false + check res + + asyncTest "Discarded result Future[T] test": var completedFutures = 0 proc client1() {.async.} = @@ -209,9 +207,8 @@ suite "Future[T] behavior test suite": discard client5() discard client5f() - waitFor(sleepAsync(2000.milliseconds)) - check: - completedFutures == 10 + await sleepAsync(1.seconds) + check completedFutures == 10 test "allFutures(zero) test": var tseq = newSeq[Future[int]]() @@ -219,7 +216,7 @@ suite "Future[T] behavior test suite": check: fut.finished - test "allFutures(varargs) test": + asyncTest "allFutures(varargs) test": var completedFutures = 0 proc vlient1() {.async.} = @@ -327,32 +324,27 @@ suite "Future[T] behavior test suite": if true: raise newException(ValueError, "") - waitFor(allFutures(vlient1(), vlient2(), vlient3(), vlient4(), vlient5())) - - check: completedFutures == 5 - completedFutures = 0 - - waitFor(allFutures(vlient1(), vlient1f(), - vlient2(), vlient2f(), - vlient3(), vlient3f(), - vlient4(), vlient4f(), - vlient5(), vlient5f())) - - check: completedFutures == 10 + await allFutures(vlient1(), vlient2(), vlient3(), vlient4(), vlient5()) + check completedFutures == 5 completedFutures = 0 - waitFor(allFutures(client1(), client2(), client3(), client4(), client5())) - check: completedFutures == 5 + + await allFutures(vlient1(), vlient1f(), vlient2(), vlient2f(), vlient3(), + vlient3f(), vlient4(), vlient4f(), vlient5(), vlient5f()) + check completedFutures == 10 completedFutures = 0 - waitFor(allFutures(client1(), client1f(), - client2(), client2f(), - client3(), client3f(), - client4(), client4f(), - client5(), client5f())) - check: completedFutures == 10 - test "allFutures(varargs) test": + await allFutures(client1(), client2(), client3(), client4(), client5()) + check completedFutures == 5 + + completedFutures = 0 + + await allFutures(client1(), client1f(), client2(), client2f(), client3(), + client3f(), client4(), client4f(), client5(), client5f()) + check completedFutures == 10 + + asyncTest "allFutures(varargs) test": var completedFutures = 0 var vfutures = newSeq[Future[void]]() var nfutures = newSeq[Future[int]]() @@ -470,9 +462,9 @@ suite "Future[T] behavior test suite": vfutures.add(vlient4()) vfutures.add(vlient5()) - waitFor(allFutures(vfutures)) + await allFutures(vfutures) # 5 * 10 completed futures = 50 - check: completedFutures == 50 + check completedFutures == 50 completedFutures = 0 vfutures.setLen(0) @@ -488,9 +480,9 @@ suite "Future[T] behavior test suite": vfutures.add(vlient5()) vfutures.add(vlient5f()) - waitFor(allFutures(vfutures)) + await allFutures(vfutures) # 10 * 10 completed futures = 100 - check: completedFutures == 100 + check completedFutures == 100 completedFutures = 0 nfutures.setLen(0) @@ -501,9 +493,9 @@ suite "Future[T] behavior test suite": nfutures.add(client4()) nfutures.add(client5()) - waitFor(allFutures(nfutures)) + await allFutures(nfutures) # 5 * 10 completed futures = 50 - check: completedFutures == 50 + check completedFutures == 50 completedFutures = 0 nfutures.setLen(0) @@ -519,10 +511,10 @@ suite "Future[T] behavior test suite": nfutures.add(client5()) nfutures.add(client5f()) - waitFor(allFutures(nfutures)) + await allFutures(nfutures) # 10 * 10 completed futures = 100 - check: completedFutures == 100 + check completedFutures == 100 test "allFutures() already completed test": proc client1(): Future[int] {.async.} = @@ -556,7 +548,7 @@ suite "Future[T] behavior test suite": var fut = one(tseq) check: fut.finished and fut.failed - test "one(varargs) test": + asyncTest "one(varargs) test": proc vlient1() {.async.} = await sleepAsync(100.milliseconds) @@ -581,17 +573,17 @@ suite "Future[T] behavior test suite": var fut11 = vlient1() var fut12 = vlient2() var fut13 = vlient3() - var res1 = waitFor(one(fut11, fut12, fut13)) + var res1 = await one(fut11, fut12, fut13) var fut21 = vlient2() var fut22 = vlient1() var fut23 = vlient3() - var res2 = waitFor(one(fut21, fut22, fut23)) + var res2 = await one(fut21, fut22, fut23) var fut31 = vlient3() var fut32 = vlient2() var fut33 = vlient1() - var res3 = waitFor(one(fut31, fut32, fut33)) + var res3 = await one(fut31, fut32, fut33) check: fut11 == res1 @@ -601,24 +593,24 @@ suite "Future[T] behavior test suite": var cut11 = client1() var cut12 = client2() var cut13 = client3() - var res4 = waitFor(one(cut11, cut12, cut13)) + var res4 = await one(cut11, cut12, cut13) var cut21 = client2() var cut22 = client1() var cut23 = client3() - var res5 = waitFor(one(cut21, cut22, cut23)) + var res5 = await one(cut21, cut22, cut23) var cut31 = client3() var cut32 = client2() var cut33 = client1() - var res6 = waitFor(one(cut31, cut32, cut33)) + var res6 = await one(cut31, cut32, cut33) check: cut11 == res4 cut22 == res5 cut33 == res6 - test "one(seq) test": + asyncTest "one(seq) test": proc vlient1() {.async.} = await sleepAsync(100.milliseconds) @@ -643,17 +635,17 @@ suite "Future[T] behavior test suite": var v10 = vlient1() var v11 = vlient2() var v12 = vlient3() - var res1 = waitFor(one(@[v10, v11, v12])) + var res1 = await one(@[v10, v11, v12]) var v20 = vlient2() var v21 = vlient1() var v22 = vlient3() - var res2 = waitFor(one(@[v20, v21, v22])) + var res2 = await one(@[v20, v21, v22]) var v30 = vlient3() var v31 = vlient2() var v32 = vlient1() - var res3 = waitFor(one(@[v30, v31, v32])) + var res3 = await one(@[v30, v31, v32]) check: res1 == v10 @@ -663,17 +655,17 @@ suite "Future[T] behavior test suite": var c10 = client1() var c11 = client2() var c12 = client3() - var res4 = waitFor(one(@[c10, c11, c12])) + var res4 = await one(@[c10, c11, c12]) var c20 = client2() var c21 = client1() var c22 = client3() - var res5 = waitFor(one(@[c20, c21, c22])) + var res5 = await one(@[c20, c21, c22]) var c30 = client3() var c31 = client2() var c32 = client1() - var res6 = waitFor(one(@[c30, c31, c32])) + var res6 = await one(@[c30, c31, c32]) check: res4 == c10 @@ -709,13 +701,7 @@ suite "Future[T] behavior test suite": not(fut2.failed()) fut2.read() == f21 - proc waitForNeLocal[T](fut: Future[T]): Future[T] = - ## **Blocks** the current thread until the specified future completes. - while not(fut.finished()): - poll() - result = fut - - test "or() test": + asyncTest "or() test": proc client1() {.async.} = await sleepAsync(200.milliseconds) @@ -730,32 +716,163 @@ suite "Future[T] behavior test suite": proc client4() {.async.} = await sleepAsync(400.milliseconds) if true: - raise newException(KeyError, "") + raise newException(IOError, "") - var f1 = waitForNeLocal(client1() or client2()) - var f2 = waitForNeLocal(client2() or client1()) - var f3 = waitForNeLocal(client1() or client4()) - var f4 = waitForNeLocal(client2() or client4()) - var f5 = waitForNeLocal(client1() or client3()) - var f6 = waitForNeLocal(client3() or client1()) - var f7 = waitForNeLocal(client2() or client4()) - var f8 = waitForNeLocal(client4() or client2()) - var f9 = waitForNeLocal(client3() or client4()) - var f10 = waitForNeLocal(client4() or client3()) + proc client5() {.async.} = + discard - check: - (f1.finished() and not(f1.failed())) - (f2.finished() and not(f2.failed())) - (f3.finished() and not(f3.failed())) - (f4.finished() and not(f4.failed())) - (f5.finished() and f5.failed()) - (f6.finished() and f6.failed()) - (f7.finished() and not(f7.failed())) - (f8.finished() and not(f8.failed())) - (f9.finished() and f9.failed()) - (f10.finished() and f10.failed()) + proc client6() {.async.} = + if true: + raise newException(ValueError, "") - test "or() already completed test": + proc client7() {.async.} = + if true: + raise newException(IOError, "") + + block: + let res = + try: + await client1() or client2() + true + except CatchableError: + false + check res + + block: + let res = + try: + await client2() or client1() + true + except CatchableError: + false + check res + + block: + let res = + try: + await client1() or client4() + true + except IOError: + false + except CatchableError: + false + check res + + block: + let res = + try: + await client2() or client4() + true + except IOError: + false + except CatchableError: + false + check res + + block: + let res = + try: + await client4() or client2() + true + except IOError: + false + except CatchableError: + false + check res + + block: + let res = + try: + await client1() or client3() + false + except ValueError: + true + except CatchableError: + false + check res + + block: + let res = + try: + await client3() or client1() + false + except ValueError: + true + except CatchableError: + false + check res + + block: + let res = + try: + await client3() or client4() + false + except ValueError: + true + except CatchableError: + false + check res + + block: + let res = + try: + await client4() or client3() + false + except ValueError: + true + except CatchableError: + false + check res + + block: + let res = + try: + await client5() or client6() + true + except ValueError: + false + except CatchableError: + false + check res + + block: + let res = + try: + await client6() or client5() + false + except ValueError: + true + except CatchableError: + false + check res + + block: + let res = + try: + await client6() or client7() + false + except ValueError: + true + except IOError: + false + except CatchableError: + false + check res + + block: + let res = + try: + await client7() or client6() + false + except ValueError: + false + except IOError: + true + except CatchableError: + false + check res + + asyncTest "or() already completed test": proc client1(): Future[int] {.async.} = result = 1 proc client2(): Future[int] {.async.} = @@ -765,22 +882,85 @@ suite "Future[T] behavior test suite": await sleepAsync(100.milliseconds) result = 3 - var f1 = client1() or client2() - var f2 = client1() or client3() - var f3 = client2() or client3() - var f4 = client2() or client1() - var f5 = client3() or client1() - var f6 = client3() or client2() + block: + let res = + try: + await client1() or client2() + true + except ValueError: + false + except CatchableError: + false + check res - check: - (f1.finished() and not(f1.failed())) and - (f2.finished() and not(f2.failed())) and - (f3.finished() and f3.failed()) and - (f4.finished() and f4.failed()) and - (f5.finished() and not(f5.failed())) and - (f6.finished() and f6.failed()) + block: + var fut1 = client1() + var fut2 = client3() + let res = + try: + await fut1 or fut2 + true + except ValueError: + false + except CatchableError: + false + let discarded {.used.} = await fut2 + check res - test "cancel() async procedure test": + block: + var fut1 = client2() + var fut2 = client3() + let res = + try: + await fut1 or fut2 + false + except ValueError: + true + except CatchableError: + false + let discarded {.used.} = await fut2 + check res + + block: + let res = + try: + await client2() or client1() + false + except ValueError: + true + except CatchableError: + false + check res + + block: + var fut1 = client3() + var fut2 = client1() + let res = + try: + await fut1 or fut2 + true + except ValueError: + false + except CatchableError: + false + let discarded {.used.} = await fut1 + check res + + block: + var fut1 = client3() + var fut2 = client2() + let res = + try: + await fut1 or fut2 + false + except ValueError: + true + except CatchableError: + false + let discarded {.used.} = await fut1 + check res + + asyncTest "cancel() async procedure test": var completed = 0 proc client1() {.async.} = @@ -808,11 +988,11 @@ suite "Future[T] behavior test suite": not fut.cancelled() expect(CancelledError): - waitFor fut + await fut - check: completed == 0 + check completed == 0 - test "cancelAndWait() test": + asyncTest "cancelAndWait() test": var completed = 0 proc client1() {.async.} = @@ -832,11 +1012,10 @@ suite "Future[T] behavior test suite": inc(completed) var fut = client4() - waitFor cancelAndWait(fut) - check: - fut.cancelled() + await cancelAndWait(fut) + check fut.cancelled() - test "Break cancellation propagation test": + asyncTest "Break cancellation propagation test": var completed = 0 proc client1() {.async.} = @@ -853,15 +1032,14 @@ suite "Future[T] behavior test suite": var fut1 = client2() var fut2 = client2() fut1.cancel() - waitFor fut1 - waitFor cancelAndWait(fut2) - + await fut1 + await cancelAndWait(fut2) check: not fut1.cancelled() not fut2.cancelled() completed == 2 - test "Cancellation callback test": + asyncTest "Cancellation callback test": var completed = 0 var cancelled = 0 @@ -887,14 +1065,13 @@ suite "Future[T] behavior test suite": var fut = client1(100.milliseconds) fut.cancel() - waitFor(sleepAsync(500.milliseconds)) - + await sleepAsync(500.milliseconds) check: fut.cancelled() completed == 0 cancelled == 1 - proc testWaitAsync(): Future[bool] {.async.} = + asyncTest "Cancellation wait() test": var neverFlag1, neverFlag2, neverFlag3: bool var waitProc1, waitProc2: bool proc neverEndingProc(): Future[void] = @@ -913,16 +1090,18 @@ suite "Future[T] behavior test suite": await wait(neverEndingProc(), 100.milliseconds) except CancelledError: waitProc1 = true + except CatchableError: + doAssert(false) finally: waitProc2 = true var fut = waitProc() await cancelAndWait(fut) - result = (fut.state == FutureState.Finished) and - neverFlag1 and neverFlag2 and neverFlag3 and - waitProc1 and waitProc2 + check: + fut.state == FutureState.Finished + neverFlag1 and neverFlag2 and neverFlag3 and waitProc1 and waitProc2 - proc testWithTimeoutAsync(): Future[bool] {.async.} = + asyncTest "Cancellation withTimeout() test": var neverFlag1, neverFlag2, neverFlag3: bool var waitProc1, waitProc2: bool proc neverEndingProc(): Future[void] = @@ -942,16 +1121,18 @@ suite "Future[T] behavior test suite": doAssert(false) except CancelledError: waitProc1 = true + except CatchableError: + doAssert(false) finally: waitProc2 = true var fut = withTimeoutProc() await cancelAndWait(fut) - result = (fut.state == FutureState.Finished) and - neverFlag1 and neverFlag2 and neverFlag3 and - waitProc1 and waitProc2 + check: + fut.state == FutureState.Finished + neverFlag1 and neverFlag2 and neverFlag3 and waitProc1 and waitProc2 - proc testCancellationRaceAsync(): Future[bool] {.async.} = + asyncTest "Cancellation race test": var someFut = newFuture[void]() proc raceProc(): Future[void] {.async.} = @@ -971,21 +1152,12 @@ suite "Future[T] behavior test suite": someFut.cancel() await cancelAndWait(raceFut3) - result = (raceFut1.state == FutureState.Cancelled) and - (raceFut2.state == FutureState.Cancelled) and - (raceFut3.state == FutureState.Cancelled) - - test "Cancellation wait() test": - check: waitFor(testWaitAsync()) - - test "Cancellation withTimeout() test": - check: waitFor(testWithTimeoutAsync()) - - test "Cancellation race test": - check: waitFor(testCancellationRaceAsync()) - - proc testAsyncSpawnAsync(): Future[bool] {.async.} = + check: + raceFut1.state == FutureState.Cancelled + raceFut2.state == FutureState.Cancelled + raceFut3.state == FutureState.Cancelled + asyncTest "asyncSpawn() test": proc completeTask1() {.async.} = discard @@ -999,47 +1171,55 @@ suite "Future[T] behavior test suite": proc cancelTask() {.async.} = await sleepAsync(10.seconds) - try: - var fut1 = completeTask1() - var fut2 = completeTask2() - asyncSpawn fut1 - asyncSpawn fut2 - await sleepAsync(200.milliseconds) - if not(fut1.finished()) or not(fut2.finished()): - return false - if fut1.failed() or fut1.cancelled() or fut2.failed() or fut2.cancelled(): - return false - except: - return false + block: + let res = + try: + var fut1 = completeTask1() + var fut2 = completeTask2() + asyncSpawn fut1 + asyncSpawn fut2 + await sleepAsync(200.milliseconds) + if not(fut1.finished()) or not(fut2.finished()): + false + else: + if fut1.failed() or fut1.cancelled() or fut2.failed() or + fut2.cancelled(): + false + else: + true + except CatchableError: + false + check res - try: - asyncSpawn errorTask() - return false - except FutureDefect: - discard - except: - return false + block: + let res = + try: + asyncSpawn errorTask() + false + except FutureDefect: + true + except CatchableError: + false + check res - try: - var fut = cancelTask() - await cancelAndWait(fut) - asyncSpawn fut - return false - except FutureDefect: - discard - except: - return false - - return true - - test "asyncSpawn() test": - check: waitFor(testAsyncSpawnAsync()) + block: + let res = + try: + var fut = cancelTask() + await cancelAndWait(fut) + asyncSpawn fut + false + except FutureDefect: + true + except CatchableError: + false + check res test "location test": # WARNING: This test is very sensitive to line numbers and module name. - proc macroFuture() {.async.} = - let someVar {.used.} = 5 + proc macroFuture() {.async.} = # LINE POSITION 1 + let someVar {.used.} = 5 # LINE POSITION 2 let someOtherVar {.used.} = 4 if true: let otherVar {.used.} = 3 @@ -1048,14 +1228,14 @@ suite "Future[T] behavior test suite": newFuture[void]("template") proc procFuture(): Future[void] = - newFuture[void]("procedure") + newFuture[void]("procedure") # LINE POSITION 5 var fut1 = macroFuture() - var fut2 = templateFuture() + var fut2 = templateFuture() # LINE POSITION 3 var fut3 = procFuture() - fut2.complete() - fut3.complete() + fut2.complete() # LINE POSITION 4 + fut3.complete() # LINE POSITION 6 let loc10 = fut1.location[0] let loc11 = fut1.location[1] @@ -1073,58 +1253,58 @@ suite "Future[T] behavior test suite": (loc.procedure == procedure) check: - chk(loc10, "testfut.nim", 1041, "macroFuture") - chk(loc11, "testfut.nim", 1042, "") - chk(loc20, "testfut.nim", 1054, "template") - chk(loc21, "testfut.nim", 1057, "") - chk(loc30, "testfut.nim", 1051, "procedure") - chk(loc31, "testfut.nim", 1058, "") + chk(loc10, "testfut.nim", 1221, "macroFuture") + chk(loc11, "testfut.nim", 1222, "") + chk(loc20, "testfut.nim", 1234, "template") + chk(loc21, "testfut.nim", 1237, "") + chk(loc30, "testfut.nim", 1231, "procedure") + chk(loc31, "testfut.nim", 1238, "") - test "withTimeout(fut) should wait cancellation test": + asyncTest "withTimeout(fut) should wait cancellation test": proc futureNeverEnds(): Future[void] = newFuture[void]("neverending.future") proc futureOneLevelMore() {.async.} = await futureNeverEnds() - proc testWithTimeout(): Future[bool] {.async.} = - var fut = futureOneLevelMore() - try: - let res = await withTimeout(fut, 100.milliseconds) - # Because `fut` is never-ending Future[T], `withTimeout` should return - # `false` but it also has to wait until `fut` is cancelled. - if not(res) and fut.cancelled(): - return true - else: - return false - except CatchableError: - return false + let res = + block: + var fut = futureOneLevelMore() + try: + let res = await withTimeout(fut, 100.milliseconds) + # Because `fut` is never-ending Future[T], `withTimeout` should return + # `false` but it also has to wait until `fut` is cancelled. + if not(res) and fut.cancelled(): + true + else: + false + except CatchableError: + false + check res - check: waitFor testWithTimeout() - - test "wait(fut) should wait cancellation test": + asyncTest "wait(fut) should wait cancellation test": proc futureNeverEnds(): Future[void] = newFuture[void]("neverending.future") proc futureOneLevelMore() {.async.} = await futureNeverEnds() - proc testWait(): Future[bool] {.async.} = - var fut = futureOneLevelMore() + var fut = futureOneLevelMore() + let res = try: await wait(fut, 100.milliseconds) - return false + false except AsyncTimeoutError: # Because `fut` is never-ending Future[T], `wait` should raise # `AsyncTimeoutError`, but only after `fut` is cancelled. if fut.cancelled(): - return true + true else: - return false + false except CatchableError: - return false + false - check: waitFor testWait() + check res test "race(zero) test": var tseq = newSeq[FutureBase]() @@ -1136,7 +1316,7 @@ suite "Future[T] behavior test suite": fut2.failed() fut3.failed() - test "race(varargs) test": + asyncTest "race(varargs) test": proc vlient1() {.async.} = await sleepAsync(100.milliseconds) @@ -1173,30 +1353,32 @@ suite "Future[T] behavior test suite": var fut11 = vlient1() var fut12 = ilient2() var fut13 = slient3() - var res1 = waitFor(race(fut11, fut12, fut13)) + var res1 = await race(fut11, fut12, fut13) + check FutureBase(fut11) == res1 + await allFutures(fut12, fut13) var fut21 = vlient2() var fut22 = ilient1() var fut23 = slient3() - var res2 = waitFor(race(fut21, fut22, fut23)) + var res2 = await race(fut21, fut22, fut23) + check FutureBase(fut22) == res2 + await allFutures(fut21, fut23) var fut31 = vlient3() var fut32 = ilient2() var fut33 = slient1() - var res3 = waitFor(race(fut31, fut32, fut33)) + var res3 = await race(fut31, fut32, fut33) + check FutureBase(fut33) == res3 + await allFutures(fut31, fut32) var fut41 = vlient1() var fut42 = slient2() var fut43 = ilient3() - var res4 = waitFor(race(fut41, fut42, fut43)) + var res4 = await race(fut41, fut42, fut43) + check FutureBase(fut41) == res4 + await allFutures(fut42, fut43) - check: - FutureBase(fut11) == res1 - FutureBase(fut22) == res2 - FutureBase(fut33) == res3 - FutureBase(fut41) == res4 - - test "race(seq) test": + asyncTest "race(seq) test": proc vlient1() {.async.} = await sleepAsync(100.milliseconds) @@ -1233,34 +1415,32 @@ suite "Future[T] behavior test suite": var v10 = vlient1() var v11 = ilient2() var v12 = slient3() - var res1 = waitFor(race(@[FutureBase(v10), FutureBase(v11), - FutureBase(v12)])) + var res1 = await race(@[FutureBase(v10), FutureBase(v11), FutureBase(v12)]) + check res1 == FutureBase(v10) + await allFutures(v11, v12) var v20 = vlient2() var v21 = ilient1() var v22 = slient3() - var res2 = waitFor(race(@[FutureBase(v20), FutureBase(v21), - FutureBase(v22)])) + var res2 = await race(@[FutureBase(v20), FutureBase(v21), FutureBase(v22)]) + check res2 == FutureBase(v21) + await allFutures(v20, v22) var v30 = vlient3() var v31 = ilient2() var v32 = slient1() - var res3 = waitFor(race(@[FutureBase(v30), FutureBase(v31), - FutureBase(v32)])) + var res3 = await race(@[FutureBase(v30), FutureBase(v31), FutureBase(v32)]) + check res3 == FutureBase(v32) + await allFutures(v30, v31) var v40 = vlient1() var v41 = slient2() var v42 = ilient3() - var res4 = waitFor(race(@[FutureBase(v40), FutureBase(v41), - FutureBase(v42)])) + var res4 = await race(@[FutureBase(v40), FutureBase(v41), FutureBase(v42)]) + check res4 == FutureBase(v40) + await allFutures(v41, v42) - check: - res1 == FutureBase(v10) - res2 == FutureBase(v21) - res3 == FutureBase(v32) - res4 == FutureBase(v40) - - test "race() already completed test": + asyncTest "race() already completed test": proc client1(): Future[int] {.async.} = result = 1 @@ -1285,7 +1465,9 @@ suite "Future[T] behavior test suite": fut1.done() and fut1.read() == FutureBase(f10) fut2.done() and fut2.read() == FutureBase(f21) - test "race() cancellation test": + await allFutures(f20, f30, f11, f31) + + asyncTest "race() cancellation test": proc client1() {.async.} = await sleepAsync(100.milliseconds) @@ -1301,14 +1483,14 @@ suite "Future[T] behavior test suite": var f2 = client2() var f3 = client3() var fut = race(f1, f2, f3) - waitFor(cancelAndWait(fut)) + await cancelAndWait(fut) check: - not f1.finished() - not f2.finished() - not f3.finished() + not(f1.finished()) + not(f2.finished()) + not(f3.finished()) - waitFor(sleepAsync(400.milliseconds)) + await sleepAsync(500.milliseconds) check: f1.finished()