Add AsyncSemaphore tests.

Author: cheatfate

chronos/asyncsync.nim

@@ -207,21 +207,27 @@ proc isSet*(event: AsyncEvent): bool =
   ## Return `true` if and only if the internal flag of ``event`` is `true`.
   event.flag
 
+proc wakeupNext(waiters: var seq[Future[void]]) {.inline.} =
+  var i = 0
+  while i < len(waiters):
+    var waiter = waiters[i]
+    inc(i)
+
+    if not(waiter.finished()):
+      waiter.complete()
+      break
+
+  if i > 0:
+    waiters.delete(0, i - 1)
+
 proc newAsyncSemaphore*(value: int = 1): AsyncSemaphore =
   ## Creates a new asynchronous bounded semaphore ``AsyncSemaphore`` with
   ## internal counter set to ``value``.
-  doAssert(value < 0, "AsyncSemaphore initial value must be bigger or equal 0")
+  doAssert(value >= 0, "AsyncSemaphore initial value must be bigger or equal 0")
   discard getThreadDispatcher()
   AsyncSemaphore(waiters: newSeq[Future[void]](), counter: value,
                  maxcounter: value)
 
-proc wakeupNext(asem: AsyncSemaphore) {.inline.} =
-  while len(asem.waiters) > 0:
-    let waiter = asem.waiters.pop()
-    if not(waiter.finished()):
-      waiter.complete()
-      return
-
 proc locked*(asem: AsyncSemaphore): bool =
   ## Returns ``true`` if semaphore can not be acquired immediately
   (asem.counter == 0)
@@ -239,7 +245,7 @@ proc acquire*(asem: AsyncSemaphore) {.async.} =
       await waiter
     except CatchableError as exc:
       if asem.counter > 0 and not(waiter.cancelled()):
-        asem.wakeupNext()
+        asem.waiters.wakeupNext()
       raise exc
   dec(asem.counter)
 
@@ -248,7 +254,7 @@ proc release*(asem: AsyncSemaphore) =
   if asem.counter >= asem.maxcounter:
     raiseAssert("AsyncSemaphore released too many times")
   inc(asem.counter)
-  asem.wakeupNext()
+  asem.waiters.wakeupNext()
 
 proc newAsyncQueue*[T](maxsize: int = 0): AsyncQueue[T] =
   ## Creates a new asynchronous queue ``AsyncQueue``.
@@ -279,19 +285,6 @@ proc newAsyncPriorityQueue*[T](maxsize: int = 0): AsyncPriorityQueue[T] =
     maxsize: maxsize
   )
 
-proc wakeupNext(waiters: var seq[Future[void]]) {.inline.} =
-  var i = 0
-  while i < len(waiters):
-    var waiter = waiters[i]
-    inc(i)
-
-    if not(waiter.finished()):
-      waiter.complete()
-      break
-
-  if i > 0:
-    waiters.delete(0, i - 1)
-
 proc full*[T](aq: AsyncQueue[T] | AsyncPriorityQueue[T]): bool {.inline.} =
   ## Return ``true`` if there are ``maxsize`` items in the queue.
   ##

tests/testsync.nim

@@ -37,7 +37,7 @@ suite "Asynchronous sync primitives test suite":
     discard testLock(9, lock)
     lock.release()
     ## There must be exactly 20 poll() calls
-    for i in 0..<20:
+    for i in 0 ..< 20:
       poll()
     result = testLockResult
 
@@ -344,13 +344,97 @@ suite "Asynchronous sync primitives test suite":
     var queue1 = newAsyncPriorityQueue[int](10)
     var queue2 = newAsyncPriorityQueue[int](1)
 
-    var fut1 = task2(queue1)
+    discard task2(queue1)
     let r1 = waitFor task1(queue1)
-    var fut2 = task2(queue2)
+    discard task2(queue2)
     let r2 = waitFor task1(queue2)
 
     return r1 == "0123456789" and r2 == "6593482107"
 
+  proc testAsyncSemaphoreBehavior(): bool =
+    var res = ""
+
+    proc testSemaphore(n: int, sem: AsyncSemaphore) {.async.} =
+      await sem.acquire()
+      res = res & $n
+      sem.release()
+
+    proc test(): Future[string] {.async.} =
+      var sem = newAsyncSemaphore()
+      await sem.acquire()
+      discard testSemaphore(0, sem)
+      discard testSemaphore(1, sem)
+      discard testSemaphore(2, sem)
+      discard testSemaphore(3, sem)
+      discard testSemaphore(4, sem)
+      discard testSemaphore(5, sem)
+      discard testSemaphore(6, sem)
+      discard testSemaphore(7, sem)
+      discard testSemaphore(8, sem)
+      discard testSemaphore(9, sem)
+      sem.release()
+      for i in 0 ..< 20:
+        poll()
+      return res
+
+    return waitFor(test()) == "0123456789"
+
+  proc testAsyncSemaphoreDoubleRelease(): bool =
+    var res = ""
+
+    proc testSemaphore(n: int, sem: AsyncSemaphore) {.async.} =
+      await sem.acquire()
+      res = res & $n
+      sem.release()
+
+    proc test(): Future[bool] {.async.} =
+      var sem = newAsyncSemaphore()
+      await sem.acquire()
+      var fut1 = testSemaphore(0, sem)
+      sem.release()
+      await sem.acquire()
+      await sleepAsync(50.milliseconds)
+      if fut1.finished() == true:
+        return false
+      sem.release()
+      await sleepAsync(50.milliseconds)
+      if fut1.finished() == false:
+        return false
+      return res == "0"
+
+    return waitFor(test())
+
+  proc testAsyncSemaphoreCounter(): bool =
+    var res = ""
+
+    proc testSemaphore(n: int, sem: AsyncSemaphore) {.async.} =
+      await sem.acquire()
+      res = res & $n
+
+    proc test(): Future[bool] {.async.} =
+      var sem = newAsyncSemaphore(3)
+      discard testSemaphore(0, sem)
+      discard testSemaphore(1, sem)
+      discard testSemaphore(2, sem)
+      discard testSemaphore(3, sem)
+      discard testSemaphore(4, sem)
+      discard testSemaphore(5, sem)
+      await sleepAsync(50.milliseconds)
+      if res != "012":
+        return false
+      sem.release()
+      await sleepAsync(50.milliseconds)
+      if res != "0123":
+        return false
+      sem.release()
+      sem.release()
+      await sleepAsync(50.milliseconds)
+      if res != "012345":
+        return false
+      return true
+
+    return waitFor(test())
+
   test "AsyncLock() behavior test":
     check:
       test1() == "0123456789"
@@ -392,3 +476,9 @@ suite "Asynchronous sync primitives test suite":
     check testPriorityBehavior() == 3000
   test "AsyncPriorityQueue() priority test":
     check testPriorityQueue() == true
+  test "AsyncSemaphore() behavior test":
+    check testAsyncSemaphoreBehavior() == true
+  test "AsyncSemaphore() double release test":
+    check testAsyncSemaphoreDoubleRelease() == true
+  test "AsyncSemaphore() counter test":
+    check testAsyncSemaphoreCounter() == true