555 lines
13 KiB
Nim
555 lines
13 KiB
Nim
# Chronos Test Suite
|
|
# (c) Copyright 2018-Present
|
|
# Status Research & Development GmbH
|
|
#
|
|
# Licensed under either of
|
|
# Apache License, version 2.0, (LICENSE-APACHEv2)
|
|
# MIT license (LICENSE-MIT)
|
|
|
|
import unittest
|
|
import ../chronos
|
|
|
|
proc testFuture1(): Future[int] {.async.} =
|
|
await sleepAsync(100)
|
|
|
|
proc testFuture2(): Future[int] {.async.} =
|
|
return 1
|
|
|
|
proc testFuture3(): Future[int] {.async.} =
|
|
result = await testFuture2()
|
|
|
|
proc testFuture4(): Future[int] {.async.} =
|
|
## Test for not immediately completed future and timeout = -1
|
|
result = 0
|
|
try:
|
|
var res = await wait(testFuture1(), -1)
|
|
result = 1
|
|
except:
|
|
result = 0
|
|
|
|
if result == 0:
|
|
return -1
|
|
|
|
## Test for immediately completed future and timeout = -1
|
|
result = 0
|
|
try:
|
|
var res = await wait(testFuture2(), -1)
|
|
result = 2
|
|
except:
|
|
result = 0
|
|
|
|
if result == 0:
|
|
return -2
|
|
|
|
## Test for not immediately completed future and timeout = 0
|
|
result = 0
|
|
try:
|
|
var res = await wait(testFuture1(), 0)
|
|
except AsyncTimeoutError:
|
|
result = 3
|
|
|
|
if result == 0:
|
|
return -3
|
|
|
|
## Test for immediately completed future and timeout = 0
|
|
result = 0
|
|
try:
|
|
var res = await wait(testFuture2(), 0)
|
|
result = 4
|
|
except:
|
|
result = 0
|
|
|
|
if result == 0:
|
|
return -4
|
|
|
|
## Test for future which cannot be completed in timeout period
|
|
result = 0
|
|
try:
|
|
var res = await wait(testFuture1(), 50)
|
|
except AsyncTimeoutError:
|
|
result = 5
|
|
|
|
if result == 0:
|
|
return -5
|
|
|
|
## Test for future which will be completed before timeout exceeded.
|
|
try:
|
|
var res = await wait(testFuture1(), 300)
|
|
result = 6
|
|
except:
|
|
result = -6
|
|
|
|
proc test1(): bool =
|
|
var fut = testFuture1()
|
|
poll()
|
|
poll()
|
|
result = fut.finished
|
|
|
|
proc test2(): bool =
|
|
var fut = testFuture3()
|
|
result = fut.finished
|
|
|
|
proc test3(): string =
|
|
var testResult = ""
|
|
var fut = testFuture1()
|
|
fut.addCallback proc(udata: pointer) =
|
|
testResult &= "1"
|
|
fut.addCallback proc(udata: pointer) =
|
|
testResult &= "2"
|
|
fut.addCallback proc(udata: pointer) =
|
|
testResult &= "3"
|
|
fut.addCallback proc(udata: pointer) =
|
|
testResult &= "4"
|
|
fut.addCallback proc(udata: pointer) =
|
|
testResult &= "5"
|
|
discard waitFor(fut)
|
|
poll()
|
|
if fut.finished:
|
|
result = testResult
|
|
|
|
proc test4(): string =
|
|
var testResult = ""
|
|
var fut = testFuture1()
|
|
proc cb1(udata: pointer) =
|
|
testResult &= "1"
|
|
proc cb2(udata: pointer) =
|
|
testResult &= "2"
|
|
proc cb3(udata: pointer) =
|
|
testResult &= "3"
|
|
proc cb4(udata: pointer) =
|
|
testResult &= "4"
|
|
proc cb5(udata: pointer) =
|
|
testResult &= "5"
|
|
fut.addCallback cb1
|
|
fut.addCallback cb2
|
|
fut.addCallback cb3
|
|
fut.addCallback cb4
|
|
fut.addCallback cb5
|
|
fut.removeCallback cb3
|
|
discard waitFor(fut)
|
|
poll()
|
|
if fut.finished:
|
|
result = testResult
|
|
|
|
proc test5(): int =
|
|
result = waitFor(testFuture4())
|
|
|
|
proc testAllVarargs(): int =
|
|
var completedFutures = 0
|
|
|
|
proc vlient1() {.async.} =
|
|
await sleepAsync(100)
|
|
inc(completedFutures)
|
|
|
|
proc vlient2() {.async.} =
|
|
await sleepAsync(200)
|
|
inc(completedFutures)
|
|
|
|
proc vlient3() {.async.} =
|
|
await sleepAsync(300)
|
|
inc(completedFutures)
|
|
|
|
proc vlient4() {.async.} =
|
|
await sleepAsync(400)
|
|
inc(completedFutures)
|
|
|
|
proc vlient5() {.async.} =
|
|
await sleepAsync(500)
|
|
inc(completedFutures)
|
|
|
|
proc vlient1f() {.async.} =
|
|
await sleepAsync(100)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
proc vlient2f() {.async.} =
|
|
await sleepAsync(100)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
proc vlient3f() {.async.} =
|
|
await sleepAsync(100)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
proc vlient4f() {.async.} =
|
|
await sleepAsync(100)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
proc vlient5f() {.async.} =
|
|
await sleepAsync(100)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
proc client1(): Future[int] {.async.} =
|
|
await sleepAsync(100)
|
|
inc(completedFutures)
|
|
result = 1
|
|
|
|
proc client2(): Future[int] {.async.} =
|
|
await sleepAsync(200)
|
|
inc(completedFutures)
|
|
result = 1
|
|
|
|
proc client3(): Future[int] {.async.} =
|
|
await sleepAsync(300)
|
|
inc(completedFutures)
|
|
result = 1
|
|
|
|
proc client4(): Future[int] {.async.} =
|
|
await sleepAsync(400)
|
|
inc(completedFutures)
|
|
result = 1
|
|
|
|
proc client5(): Future[int] {.async.} =
|
|
await sleepAsync(500)
|
|
inc(completedFutures)
|
|
result = 1
|
|
|
|
proc client1f(): Future[int] {.async.} =
|
|
await sleepAsync(100)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
proc client2f(): Future[int] {.async.} =
|
|
await sleepAsync(200)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
proc client3f(): Future[int] {.async.} =
|
|
await sleepAsync(300)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
proc client4f(): Future[int] {.async.} =
|
|
await sleepAsync(400)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
proc client5f(): Future[int] {.async.} =
|
|
await sleepAsync(500)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
waitFor(all(vlient1(), vlient2(), vlient3(), vlient4(), vlient5()))
|
|
# 5 completed futures = 5
|
|
result += completedFutures
|
|
completedFutures = 0
|
|
try:
|
|
waitFor(all(vlient1(), vlient1f(),
|
|
vlient2(), vlient2f(),
|
|
vlient3(), vlient3f(),
|
|
vlient4(), vlient4f(),
|
|
vlient5(), vlient5f()))
|
|
result -= 10000
|
|
except:
|
|
discard
|
|
# 10 completed futures = 10
|
|
result += completedFutures
|
|
|
|
completedFutures = 0
|
|
var res = waitFor(all(client1(), client2(), client3(), client4(), client5()))
|
|
for item in res:
|
|
result += item
|
|
# 5 completed futures + 5 values = 10
|
|
result += completedFutures
|
|
|
|
completedFutures = 0
|
|
try:
|
|
var res = waitFor(all(client1(), client1f(),
|
|
client2(), client2f(),
|
|
client3(), client3f(),
|
|
client4(), client4f(),
|
|
client5(), client5f()))
|
|
result -= 10000
|
|
except:
|
|
discard
|
|
# 10 completed futures = 10
|
|
result += completedFutures
|
|
|
|
proc testAllSeq(): int =
|
|
var completedFutures = 0
|
|
var vfutures = newSeq[Future[void]]()
|
|
var nfutures = newSeq[Future[int]]()
|
|
|
|
proc vlient1() {.async.} =
|
|
await sleepAsync(100)
|
|
inc(completedFutures)
|
|
|
|
proc vlient2() {.async.} =
|
|
await sleepAsync(200)
|
|
inc(completedFutures)
|
|
|
|
proc vlient3() {.async.} =
|
|
await sleepAsync(300)
|
|
inc(completedFutures)
|
|
|
|
proc vlient4() {.async.} =
|
|
await sleepAsync(400)
|
|
inc(completedFutures)
|
|
|
|
proc vlient5() {.async.} =
|
|
await sleepAsync(500)
|
|
inc(completedFutures)
|
|
|
|
proc vlient1f() {.async.} =
|
|
await sleepAsync(100)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
proc vlient2f() {.async.} =
|
|
await sleepAsync(100)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
proc vlient3f() {.async.} =
|
|
await sleepAsync(100)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
proc vlient4f() {.async.} =
|
|
await sleepAsync(100)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
proc vlient5f() {.async.} =
|
|
await sleepAsync(100)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
proc client1(): Future[int] {.async.} =
|
|
await sleepAsync(100)
|
|
inc(completedFutures)
|
|
result = 1
|
|
|
|
proc client2(): Future[int] {.async.} =
|
|
await sleepAsync(200)
|
|
inc(completedFutures)
|
|
result = 1
|
|
|
|
proc client3(): Future[int] {.async.} =
|
|
await sleepAsync(300)
|
|
inc(completedFutures)
|
|
result = 1
|
|
|
|
proc client4(): Future[int] {.async.} =
|
|
await sleepAsync(400)
|
|
inc(completedFutures)
|
|
result = 1
|
|
|
|
proc client5(): Future[int] {.async.} =
|
|
await sleepAsync(500)
|
|
inc(completedFutures)
|
|
result = 1
|
|
|
|
proc client1f(): Future[int] {.async.} =
|
|
await sleepAsync(100)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
proc client2f(): Future[int] {.async.} =
|
|
await sleepAsync(200)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
proc client3f(): Future[int] {.async.} =
|
|
await sleepAsync(300)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
proc client4f(): Future[int] {.async.} =
|
|
await sleepAsync(400)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
proc client5f(): Future[int] {.async.} =
|
|
await sleepAsync(500)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
vfutures.setLen(0)
|
|
for i in 0..<10:
|
|
vfutures.add(vlient1())
|
|
vfutures.add(vlient2())
|
|
vfutures.add(vlient3())
|
|
vfutures.add(vlient4())
|
|
vfutures.add(vlient5())
|
|
|
|
waitFor(all(vfutures))
|
|
# 5 * 10 completed futures = 50
|
|
result += completedFutures
|
|
|
|
completedFutures = 0
|
|
vfutures.setLen(0)
|
|
for i in 0..<10:
|
|
vfutures.add(vlient1())
|
|
vfutures.add(vlient1f())
|
|
vfutures.add(vlient2())
|
|
vfutures.add(vlient2f())
|
|
vfutures.add(vlient3())
|
|
vfutures.add(vlient3f())
|
|
vfutures.add(vlient4())
|
|
vfutures.add(vlient4f())
|
|
vfutures.add(vlient5())
|
|
vfutures.add(vlient5f())
|
|
|
|
try:
|
|
waitFor(all(vfutures))
|
|
result -= 10000
|
|
except:
|
|
discard
|
|
# 10 * 10 completed futures = 100
|
|
result += completedFutures
|
|
|
|
completedFutures = 0
|
|
nfutures.setLen(0)
|
|
for i in 0..<10:
|
|
nfutures.add(client1())
|
|
nfutures.add(client2())
|
|
nfutures.add(client3())
|
|
nfutures.add(client4())
|
|
nfutures.add(client5())
|
|
|
|
var res = waitFor(all(nfutures))
|
|
for i in 0..<len(nfutures):
|
|
result += res[i]
|
|
# 5 * 10 completed futures + 5 * 10 results = 100
|
|
result += completedFutures
|
|
|
|
completedFutures = 0
|
|
nfutures.setLen(0)
|
|
for i in 0..<10:
|
|
nfutures.add(client1())
|
|
nfutures.add(client1f())
|
|
nfutures.add(client2())
|
|
nfutures.add(client2f())
|
|
nfutures.add(client3())
|
|
nfutures.add(client3f())
|
|
nfutures.add(client4())
|
|
nfutures.add(client4f())
|
|
nfutures.add(client5())
|
|
nfutures.add(client5f())
|
|
|
|
try:
|
|
var results = waitFor(all(nfutures))
|
|
result -= 10000
|
|
except:
|
|
discard
|
|
|
|
# 10 * 10 completed futures + 0 * 10 results = 100
|
|
result += completedFutures
|
|
|
|
proc testAsyncDiscard(): int =
|
|
var completedFutures = 0
|
|
|
|
proc client1() {.async.} =
|
|
await sleepAsync(100)
|
|
inc(completedFutures)
|
|
|
|
proc client2() {.async.} =
|
|
await sleepAsync(200)
|
|
inc(completedFutures)
|
|
|
|
proc client3() {.async.} =
|
|
await sleepAsync(300)
|
|
inc(completedFutures)
|
|
|
|
proc client4() {.async.} =
|
|
await sleepAsync(400)
|
|
inc(completedFutures)
|
|
|
|
proc client5() {.async.} =
|
|
await sleepAsync(500)
|
|
inc(completedFutures)
|
|
|
|
proc client1f() {.async.} =
|
|
await sleepAsync(100)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
proc client2f() {.async.} =
|
|
await sleepAsync(200)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
proc client3f() {.async.} =
|
|
await sleepAsync(300)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
proc client4f() {.async.} =
|
|
await sleepAsync(400)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
proc client5f() {.async.} =
|
|
await sleepAsync(500)
|
|
inc(completedFutures)
|
|
if true:
|
|
raise newException(ValueError, "")
|
|
|
|
asyncDiscard client1()
|
|
asyncDiscard client1f()
|
|
asyncDiscard client2()
|
|
asyncDiscard client2f()
|
|
asyncDiscard client3()
|
|
asyncDiscard client3f()
|
|
asyncDiscard client4()
|
|
asyncDiscard client4f()
|
|
asyncDiscard client5()
|
|
asyncDiscard client5f()
|
|
|
|
waitFor(sleepAsync(2000))
|
|
result = completedFutures
|
|
|
|
proc testAllZero(): bool =
|
|
var tseq = newSeq[Future[int]]()
|
|
var fut = all(tseq)
|
|
result = fut.finished
|
|
|
|
when isMainModule:
|
|
suite "Future[T] behavior test suite":
|
|
test "Async undefined behavior (#7758) test":
|
|
check test1() == true
|
|
test "Immediately completed asynchronous procedure test":
|
|
check test2() == true
|
|
test "Future[T] callbacks are invoked in reverse order (#7197) test":
|
|
check test3() == "12345"
|
|
test "Future[T] callbacks not changing order after removeCallback()":
|
|
check test4() == "1245"
|
|
test "wait[T]() test":
|
|
check test5() == 6
|
|
test "all[T](varargs) test":
|
|
check testAllVarargs() == 35
|
|
test "all[T](seq) test":
|
|
check testAllSeq() == 350
|
|
test "all[T](zero) test":
|
|
check testAllZero() == true
|
|
test "asyncDiscard() test":
|
|
check testAsyncDiscard() == 10
|