Typos, add tests for #52

README.md

@@ -231,7 +231,7 @@ revoked. In consequence, the mutex may not be available even after `cancel()` ha
 
 You can wait until the mutex is available without locking it by calling `waitForUnlock()`.
 This will return a promise that resolve once the mutex can be acquired again. This operation
-will not lock the mutex, and there is no gurantee that the mutex will still be available
+will not lock the mutex, and there is no guarantee that the mutex will still be available
 once a async barrier has been encountered.
 
 Promise style:
@@ -372,7 +372,7 @@ semaphore.setValue();
 
 ### Cancelling pending locks.
 
-Pending locks can be cancelled by calling `cancel()` on the sempahore. This will reject
+Pending locks can be cancelled by calling `cancel()` on the semaphore. This will reject
 all pending locks with `E_CANCELED`:
 
 Promise style:
@@ -425,7 +425,7 @@ revoked. In consequence, the semaphore may not be available even after `cancel()
 
 You can wait until the semaphore is available without locking it by calling `waitForUnlock()`.
 This will return a promise that resolve once the semaphore can be acquired again. This operation
-will not lock the semaphore, and there is no gurantee that the semaphore will still be available
+will not lock the semaphore, and there is no guarantee that the semaphore will still be available
 once a async barrier has been encountered.
 
 Promise style:

test/mutex.ts

@@ -247,6 +247,24 @@ export const mutexSuite = (factory: (cancelError?: Error) => MutexInterface): vo
 
         assert.strictEqual(taskCalls, 2);
     });
+
+    test('waitForUnlock only unblocks when the mutex can actually be acquired again', async () => {
+        mutex.acquire();
+        mutex.acquire();
+
+        let flag = false;
+        mutex.waitForUnlock().then(() => (flag = true));
+
+        mutex.release();
+        await clock.tickAsync(0);
+
+        assert.strictEqual(flag, false);
+
+        mutex.release();
+        await clock.tickAsync(0);
+
+        assert.strictEqual(flag, true);
+    });
 };
 
 suite('Mutex', () => mutexSuite((e) => new Mutex(e)));

test/semaphoreSuite.ts

@@ -441,6 +441,24 @@ export const semaphoreSuite = (factory: (maxConcurrency: number, err?: Error) =>
         assert.deepStrictEqual([flag1, flag2], [true, true]);
     });
 
+    test('waitForUnlock only unblocks when the semaphore can actually be acquired again', async () => {
+        semaphore.acquire(2);
+        semaphore.acquire(2);
+
+        let flag = false;
+        semaphore.waitForUnlock().then(() => (flag = true));
+
+        semaphore.release(2);
+        await clock.tickAsync(0);
+
+        assert.strictEqual(flag, false);
+
+        semaphore.release(2);
+        await clock.tickAsync(0);
+
+        assert.strictEqual(flag, true);
+    });
+
     test('trying to acquire with a negative weight throws', () => {
         assert.throws(() => semaphore.acquire(-1));
     });