Speed up tests and fix flaky CancellingWaitSync() test

mqudsi · mqudsi · commit 14bc48fe9068 · 2021-10-30T22:48:15.000-05:00
diff --git a/UnitTests/AsyncSpawn.cs b/UnitTests/AsyncSpawn.cs
@@ -29,6 +29,7 @@ public async Task AsyncExecution(bool locked)
             var count = 0;
             var tasks = new List<Task>(70);
             var asyncLock = new AsyncLock();
+            var rng = new Random();
 
             {
                 using var l = locked ? await asyncLock.LockAsync() : new NullDisposable();
@@ -42,11 +43,10 @@ public async Task AsyncExecution(bool locked)
                             Assert.AreEqual(Interlocked.Increment(ref count), 1);
                             await Task.Yield();
                             Assert.AreEqual(count, 1);
-                            await Task.Delay(100);
+                            await Task.Delay(rng.Next(1, 10) * 10);
                             using (await asyncLock.LockAsync())
                             {
-                                await Task.Delay(100);
-                                await Task.Yield();
+                                await Task.Delay(rng.Next(1, 10) * 10);
                                 Assert.AreEqual(Interlocked.Decrement(ref count), 0);
                             }
 
@@ -58,10 +58,7 @@ public async Task AsyncExecution(bool locked)
                 }
             }
 
-            foreach (var task in tasks)
-            {
-                await task;
-            }
+            await Task.WhenAll(tasks);
 
             Assert.AreEqual(count, 0);
         }
diff --git a/UnitTests/CancellationTests.cs b/UnitTests/CancellationTests.cs
@@ -28,28 +28,37 @@ public void CancellingWait()
             }).Wait();
 
         }
+
         [TestMethod]
         public void CancellingWaitSync()
         {
             var asyncLock = new AsyncLock();
-            var cts = new CancellationTokenSource(500);
-            Task.Run(async () =>
+            var cts = new CancellationTokenSource(250);
+            var delayStarted = new ManualResetEventSlim(false);
+            var waiter1Finished = new SemaphoreSlim(0, 1);
+
+            new Thread(() =>
             {
                 using (asyncLock.Lock(cts.Token))
                 {
                     // hold the lock until our later attempt is called
-                    await Task.Delay(1000);
+                    delayStarted.Set();
+                    waiter1Finished.Wait();
                 }
-            });
+            }).Start();
+
             Assert.ThrowsException<OperationCanceledException>(() =>
             {
+                delayStarted.Wait();
                 using (asyncLock.Lock(cts.Token))
                 {
                     Assert.Fail("should never reach here if cancellation works properly.");
                 }
             });
-            // we should still be able to obtain a lock afterward to make sure resources were reobtained
-            var newCts= new CancellationTokenSource(1000);
+            waiter1Finished.Release(1);
+
+            // We should still be able to obtain a lock afterward to make sure resources were reobtained
+            var newCts = new CancellationTokenSource(2000);
             using (asyncLock.Lock(newCts.Token))
             {
                 // reaching this line means the test passed
diff --git a/UnitTests/MixedSyncAsync.cs b/UnitTests/MixedSyncAsync.cs
@@ -26,6 +26,7 @@ public async Task MixedSyncAsyncExecution()
             var threads = new List<Thread>(10);
             var tasks = new List<Task>(10);
             var asyncLock = new AsyncLock();
+            var rng = new Random();
 
             {
                 using var l = asyncLock.Lock();
@@ -36,7 +37,7 @@ public async Task MixedSyncAsyncExecution()
                         using (asyncLock.Lock())
                         {
                             Assert.AreEqual(Interlocked.Increment(ref count), 1);
-                            Thread.Sleep(100);
+                            Thread.Sleep(rng.Next(1, 10) * 10);
                             using (asyncLock.Lock())
                             {
                                 Thread.Sleep(10);
@@ -59,7 +60,7 @@ public async Task MixedSyncAsyncExecution()
                         {
                             Assert.AreEqual(Interlocked.Increment(ref count), 1);
                             Assert.AreEqual(count, 1);
-                            await Task.Delay(100);
+                            await Task.Delay(rng.Next(1, 10) * 10);
                             using (await asyncLock.LockAsync())
                             {
                                 await Task.Delay(10);
@@ -74,10 +75,7 @@ public async Task MixedSyncAsyncExecution()
                 }
             }
 
-            foreach (var task in tasks)
-            {
-                await task;
-            }
+            await Task.WhenAll(tasks);
             foreach (var thread in threads)
             {
                 thread.Join();
diff --git a/UnitTests/MixedSyncAsyncTimed.cs b/UnitTests/MixedSyncAsyncTimed.cs
@@ -26,6 +26,7 @@ public async Task MixedSyncAsyncExecution()
             var threads = new List<Thread>(10);
             var tasks = new List<Task>(10);
             var asyncLock = new AsyncLock();
+            var rng = new Random();
 
             {
                 using var l = asyncLock.Lock();
@@ -36,7 +37,7 @@ public async Task MixedSyncAsyncExecution()
                         using (asyncLock.Lock())
                         {
                             Assert.AreEqual(Interlocked.Increment(ref count), 1);
-                            Thread.Sleep(100);
+                            Thread.Sleep(rng.Next(1, 10) * 10);
                             using (asyncLock.Lock())
                             {
                                 Thread.Sleep(10);
@@ -60,12 +61,12 @@ public async Task MixedSyncAsyncExecution()
                         {
                             Assert.AreEqual(Interlocked.Increment(ref count), 1);
                             Assert.AreEqual(count, 1);
-                            await Task.Delay(100);
+                            await Task.Delay(rng.Next(1, 10) * 10);
                             if (captured % 2 == 0)
                             {
                                 using (await asyncLock.LockAsync())
                                 {
-                                    await Task.Delay(10);
+                                    await Task.Yield();
                                     Assert.AreEqual(Interlocked.Decrement(ref count), 0);
                                 }
                             }
@@ -81,9 +82,9 @@ public async Task MixedSyncAsyncExecution()
                                     }, TimeSpan.FromMilliseconds(1 /* guarantees no zero-ms optimizations */));
                                     Assert.IsTrue(nestedExecuted);
                                     Interlocked.Decrement(ref count);
-                                    await Task.Delay(10);
+                                    await Task.Yield();
                                     Assert.AreEqual(Interlocked.Decrement(ref count), 0);
-                                }, TimeSpan.FromMilliseconds(100));
+                                }, TimeSpan.FromMilliseconds(rng.Next(1, 10) * 10));
                                 Assert.IsTrue(executed, "TryLockAsync() did not end up executing!");
                             }
 
@@ -95,10 +96,7 @@ public async Task MixedSyncAsyncExecution()
                 }
             }
 
-            foreach (var task in tasks)
-            {
-                await task;
-            }
+            await Task.WhenAll(tasks);
             foreach (var thread in threads)
             {
                 thread.Join();
diff --git a/UnitTests/ReentranceLockoutTests.cs b/UnitTests/ReentranceLockoutTests.cs
@@ -15,7 +15,7 @@ public class ReentranceLockoutTests
         private LimitedResource _resource;
         private CountdownEvent _countdown;
         private Random _random = new Random((int)DateTime.UtcNow.Ticks);
-        private int DelayInterval => _random.Next(5, 10) * 10;
+        private int DelayInterval => _random.Next(1, 5) * 10;
 
         private void ResourceSimulation(Action action)
         {

Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,7 @@ public async Task AsyncExecution(bool locked)`
`29`	`29`	`var count = 0;`
`30`	`30`	`var tasks = new List<Task>(70);`
`31`	`31`	`var asyncLock = new AsyncLock();`
	`32`	`+ var rng = new Random();`
`32`	`33`
`33`	`34`	`{`
`34`	`35`	`using var l = locked ? await asyncLock.LockAsync() : new NullDisposable();`
`@@ -42,11 +43,10 @@ public async Task AsyncExecution(bool locked)`
`42`	`43`	`Assert.AreEqual(Interlocked.Increment(ref count), 1);`
`43`	`44`	`await Task.Yield();`
`44`	`45`	`Assert.AreEqual(count, 1);`
`45`		`- await Task.Delay(100);`
	`46`	`+ await Task.Delay(rng.Next(1, 10) * 10);`
`46`	`47`	`using (await asyncLock.LockAsync())`
`47`	`48`	`{`
`48`		`- await Task.Delay(100);`
`49`		`- await Task.Yield();`
	`49`	`+ await Task.Delay(rng.Next(1, 10) * 10);`
`50`	`50`	`Assert.AreEqual(Interlocked.Decrement(ref count), 0);`
`51`	`51`	`}`
`52`	`52`
`@@ -58,10 +58,7 @@ public async Task AsyncExecution(bool locked)`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`
`61`		`- foreach (var task in tasks)`
`62`		`- {`
`63`		`- await task;`
`64`		`- }`
	`61`	`+ await Task.WhenAll(tasks);`
`65`	`62`
`66`	`63`	`Assert.AreEqual(count, 0);`
`67`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,28 +28,37 @@ public void CancellingWait()`
`28`	`28`	`}).Wait();`
`29`	`29`
`30`	`30`	`}`
	`31`	`+`
`31`	`32`	`[TestMethod]`
`32`	`33`	`public void CancellingWaitSync()`
`33`	`34`	`{`
`34`	`35`	`var asyncLock = new AsyncLock();`
`35`		`- var cts = new CancellationTokenSource(500);`
`36`		`- Task.Run(async () =>`
	`36`	`+ var cts = new CancellationTokenSource(250);`
	`37`	`+ var delayStarted = new ManualResetEventSlim(false);`
	`38`	`+ var waiter1Finished = new SemaphoreSlim(0, 1);`
	`39`	`+`
	`40`	`+ new Thread(() =>`
`37`	`41`	`{`
`38`	`42`	`using (asyncLock.Lock(cts.Token))`
`39`	`43`	`{`
`40`	`44`	`// hold the lock until our later attempt is called`
`41`		`- await Task.Delay(1000);`
	`45`	`+ delayStarted.Set();`
	`46`	`+ waiter1Finished.Wait();`
`42`	`47`	`}`
`43`		`- });`
	`48`	`+ }).Start();`
	`49`	`+`
`44`	`50`	`Assert.ThrowsException<OperationCanceledException>(() =>`
`45`	`51`	`{`
	`52`	`+ delayStarted.Wait();`
`46`	`53`	`using (asyncLock.Lock(cts.Token))`
`47`	`54`	`{`
`48`	`55`	`Assert.Fail("should never reach here if cancellation works properly.");`
`49`	`56`	`}`
`50`	`57`	`});`
`51`		`- // we should still be able to obtain a lock afterward to make sure resources were reobtained`
`52`		`- var newCts= new CancellationTokenSource(1000);`
	`58`	`+ waiter1Finished.Release(1);`
	`59`	`+`
	`60`	`+ // We should still be able to obtain a lock afterward to make sure resources were reobtained`
	`61`	`+ var newCts = new CancellationTokenSource(2000);`
`53`	`62`	`using (asyncLock.Lock(newCts.Token))`
`54`	`63`	`{`
`55`	`64`	`// reaching this line means the test passed`
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,7 @@ public async Task MixedSyncAsyncExecution()`
`26`	`26`	`var threads = new List<Thread>(10);`
`27`	`27`	`var tasks = new List<Task>(10);`
`28`	`28`	`var asyncLock = new AsyncLock();`
	`29`	`+ var rng = new Random();`
`29`	`30`
`30`	`31`	`{`
`31`	`32`	`using var l = asyncLock.Lock();`
`@@ -36,7 +37,7 @@ public async Task MixedSyncAsyncExecution()`
`36`	`37`	`using (asyncLock.Lock())`
`37`	`38`	`{`
`38`	`39`	`Assert.AreEqual(Interlocked.Increment(ref count), 1);`
`39`		`- Thread.Sleep(100);`
	`40`	`+ Thread.Sleep(rng.Next(1, 10) * 10);`
`40`	`41`	`using (asyncLock.Lock())`
`41`	`42`	`{`
`42`	`43`	`Thread.Sleep(10);`
`@@ -59,7 +60,7 @@ public async Task MixedSyncAsyncExecution()`
`59`	`60`	`{`
`60`	`61`	`Assert.AreEqual(Interlocked.Increment(ref count), 1);`
`61`	`62`	`Assert.AreEqual(count, 1);`
`62`		`- await Task.Delay(100);`
	`63`	`+ await Task.Delay(rng.Next(1, 10) * 10);`
`63`	`64`	`using (await asyncLock.LockAsync())`
`64`	`65`	`{`
`65`	`66`	`await Task.Delay(10);`
`@@ -74,10 +75,7 @@ public async Task MixedSyncAsyncExecution()`
`74`	`75`	`}`
`75`	`76`	`}`
`76`	`77`
`77`		`- foreach (var task in tasks)`
`78`		`- {`
`79`		`- await task;`
`80`		`- }`
	`78`	`+ await Task.WhenAll(tasks);`
`81`	`79`	`foreach (var thread in threads)`
`82`	`80`	`{`
`83`	`81`	`thread.Join();`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ public class ReentranceLockoutTests`
`15`	`15`	`private LimitedResource _resource;`
`16`	`16`	`private CountdownEvent _countdown;`
`17`	`17`	`private Random _random = new Random((int)DateTime.UtcNow.Ticks);`
`18`		`- private int DelayInterval => _random.Next(5, 10) * 10;`
	`18`	`+ private int DelayInterval => _random.Next(1, 5) * 10;`
`19`	`19`
`20`	`20`	`private void ResourceSimulation(Action action)`
`21`	`21`	`{`