Avoid test deadlocks in threading WaitHandle tests

stephentoub · stephentoub · commit 080d07df03fa · 2015-08-15T14:38:57.000-04:00
A bunch of the Mutex/EventWaitHandle/Semaphore tests are waiting indefinitely for a signal.  If that signal never arrives due to the test failing, CI will end up waiting for several hours and then aborting the whole run.  This change adds timeouts to those waits.  It also changes a name used in one of the semaphore tests to be randomly generated; this should hopefully fix a pervasive failure we're seeing in CI right now.
diff --git a/src/System.Threading/tests/AutoResetEventTests.cs b/src/System.Threading/tests/AutoResetEventTests.cs
@@ -8,6 +8,8 @@
 
 public class AutoResetEventTests
 {
+    private const int FailedWaitTimeout = 30000;
+
     [Fact]
     public void Ctor()
     {
@@ -40,7 +42,7 @@ public void WaitHandleWaitAll()
         for (int i = 0; i < handles.Length; i++)
             handles[i] = new AutoResetEvent(false);
 
-        Task<bool> t = Task.Run(() => WaitHandle.WaitAll(handles));
+        Task<bool> t = Task.Run(() => WaitHandle.WaitAll(handles, FailedWaitTimeout));
         for (int i = 0; i < handles.Length; i++)
         {
             Assert.False(t.IsCompleted);
@@ -58,7 +60,7 @@ public void WaitHandleWaitAny()
         for (int i = 0; i < handles.Length; i++)
             handles[i] = new AutoResetEvent(false);
 
-        Task<int> t = Task.Run(() => WaitHandle.WaitAny(handles));
+        Task<int> t = Task.Run(() => WaitHandle.WaitAny(handles, FailedWaitTimeout));
         handles[5].Set();
         Assert.Equal(5, t.Result);
 
@@ -76,15 +78,15 @@ public void PingPong()
                 {
                     for (int i = 0; i < Iters; i++)
                     {
-                        Assert.True(are1.WaitOne());
+                        Assert.True(are1.WaitOne(FailedWaitTimeout));
                         are2.Set();
                     }
                 }, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default),
                 Task.Factory.StartNew(() =>
                 {
                     for (int i = 0; i < Iters; i++)
                     {
-                        Assert.True(are2.WaitOne());
+                        Assert.True(are2.WaitOne(FailedWaitTimeout));
                         are1.Set();
                     }
                 }, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default));
diff --git a/src/System.Threading/tests/ManualResetEventTests.cs b/src/System.Threading/tests/ManualResetEventTests.cs
@@ -8,6 +8,8 @@
 
 public class ManualResetEventTests
 {
+    private const int FailedWaitTimeout = 30000;
+
     [Fact]
     public void Ctor()
     {
@@ -41,7 +43,7 @@ public void WaitHandleWaitAll()
         for (int i = 0; i < handles.Length; i++)
             handles[i] = new ManualResetEvent(false);
 
-        Task<bool> t = Task.Run(() => WaitHandle.WaitAll(handles));
+        Task<bool> t = Task.Run(() => WaitHandle.WaitAll(handles, FailedWaitTimeout));
         for (int i = 0; i < handles.Length; i++)
         {
             Assert.False(t.IsCompleted);
@@ -59,7 +61,7 @@ public void WaitHandleWaitAny()
         for (int i = 0; i < handles.Length; i++)
             handles[i] = new ManualResetEvent(false);
 
-        Task<int> t = Task.Run(() => WaitHandle.WaitAny(handles));
+        Task<int> t = Task.Run(() => WaitHandle.WaitAny(handles, FailedWaitTimeout));
         handles[5].Set();
         Assert.Equal(5, t.Result);
 
@@ -77,7 +79,7 @@ public void PingPong()
                 {
                     for (int i = 0; i < Iters; i++)
                     {
-                        Assert.True(mre1.WaitOne());
+                        Assert.True(mre1.WaitOne(FailedWaitTimeout));
                         mre1.Reset();
                         mre2.Set();
                     }
@@ -86,7 +88,7 @@ public void PingPong()
                 {
                     for (int i = 0; i < Iters; i++)
                     {
-                        Assert.True(mre2.WaitOne());
+                        Assert.True(mre2.WaitOne(FailedWaitTimeout));
                         mre2.Reset();
                         mre1.Set();
                     }
diff --git a/src/System.Threading/tests/MutexTests.cs b/src/System.Threading/tests/MutexTests.cs
@@ -8,24 +8,26 @@
 
 public class MutexTests
 {
+    private const int FailedWaitTimeout = 30000;
+
     [Fact]
     public void Ctor_ConstructWaitRelease()
     {
         using (Mutex m = new Mutex())
         {
-            Assert.True(m.WaitOne());
+            Assert.True(m.WaitOne(FailedWaitTimeout));
             m.ReleaseMutex();
         }
 
         using (Mutex m = new Mutex(false))
         {
-            Assert.True(m.WaitOne());
+            Assert.True(m.WaitOne(FailedWaitTimeout));
             m.ReleaseMutex();
         }
 
         using (Mutex m = new Mutex(true))
         {
-            Assert.True(m.WaitOne());
+            Assert.True(m.WaitOne(FailedWaitTimeout));
             m.ReleaseMutex();
             m.ReleaseMutex();
         }
@@ -86,11 +88,11 @@ public void OpenExisting_Windows()
         {
             using (Mutex m2 = Mutex.OpenExisting(name))
             {
-                Assert.True(m1.WaitOne());
+                Assert.True(m1.WaitOne(FailedWaitTimeout));
                 Assert.False(Task.Factory.StartNew(() => m2.WaitOne(0), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default).Result);
                 m1.ReleaseMutex();
 
-                Assert.True(m2.WaitOne());
+                Assert.True(m2.WaitOne(FailedWaitTimeout));
                 Assert.False(Task.Factory.StartNew(() => m1.WaitOne(0), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default).Result);
                 m2.ReleaseMutex();
             }
@@ -106,14 +108,23 @@ public void AbandonExisting()
     {
         using (Mutex m = new Mutex())
         {
-            Task.Factory.StartNew(() => m.WaitOne(), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default).Wait();
-            Assert.Throws<AbandonedMutexException>(() => m.WaitOne());
+            Task t = Task.Factory.StartNew(() =>
+            {
+                Assert.True(m.WaitOne(FailedWaitTimeout));
+                // don't release the mutex; abandon it on this thread
+            }, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);
+            t.Wait();
+            Assert.Throws<AbandonedMutexException>(() => m.WaitOne(FailedWaitTimeout));
         }
 
         using (Mutex m = new Mutex())
         {
-            Task.Factory.StartNew(() => m.WaitOne(), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default).Wait();
-            AbandonedMutexException ame = Assert.Throws<AbandonedMutexException>(() => WaitHandle.WaitAny(new[] { m }));
+            Task t = Task.Factory.StartNew(() =>
+            {
+                Assert.True(m.WaitOne(FailedWaitTimeout));
+            }, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);
+            t.Wait();
+            AbandonedMutexException ame = Assert.Throws<AbandonedMutexException>(() => WaitHandle.WaitAny(new[] { m }, FailedWaitTimeout));
             Assert.Equal(0, ame.MutexIndex);
         }
     }
diff --git a/src/System.Threading/tests/SemaphoreTests.cs b/src/System.Threading/tests/SemaphoreTests.cs
@@ -10,6 +10,8 @@ namespace Test
 {
     public class SemaphoreTests
     {
+        private const int FailedWaitTimeout = 30000;
+
         [Theory]
         [InlineData(0, 1)]
         [InlineData(1, 1)]
@@ -154,7 +156,7 @@ public void AnonymousProducerConsumer()
                     Task.Factory.StartNew(() =>
                     {
                         for (int i = 0; i < NumItems; i++)
-                            s.WaitOne();
+                            Assert.True(s.WaitOne(FailedWaitTimeout));
                         Assert.False(s.WaitOne(0));
                     }, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default),
                     Task.Factory.StartNew(() =>
@@ -169,21 +171,21 @@ public void AnonymousProducerConsumer()
         [Fact]
         public void NamedProducerConsumer()
         {
-            const string Name = "NamedProducerConsumerSemaphoreTest";
+            string name = Guid.NewGuid().ToString("N");
             const int NumItems = 5;
             Task.WaitAll(
                 Task.Factory.StartNew(() =>
                 {
-                    using (Semaphore s = new Semaphore(0, Int32.MaxValue, Name))
+                    using (Semaphore s = new Semaphore(0, Int32.MaxValue, name))
                     {
                         for (int i = 0; i < NumItems; i++)
-                            s.WaitOne();
+                            Assert.True(s.WaitOne(1000));
                         Assert.False(s.WaitOne(0));
                     }
                 }, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default),
                 Task.Factory.StartNew(() =>
                 {
-                    using (Semaphore s = new Semaphore(0, Int32.MaxValue, Name))
+                    using (Semaphore s = new Semaphore(0, Int32.MaxValue, name))
                     {
                         for (int i = 0; i < NumItems; i++)
                             s.Release();

Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,8 @@`
`8`	`8`
`9`	`9`	`public class AutoResetEventTests`
`10`	`10`	`{`
	`11`	`+ private const int FailedWaitTimeout = 30000;`
	`12`	`+`
`11`	`13`	`[Fact]`
`12`	`14`	`public void Ctor()`
`13`	`15`	`{`
`@@ -40,7 +42,7 @@ public void WaitHandleWaitAll()`
`40`	`42`	`for (int i = 0; i < handles.Length; i++)`
`41`	`43`	`handles[i] = new AutoResetEvent(false);`
`42`	`44`
`43`		`- Task<bool> t = Task.Run(() => WaitHandle.WaitAll(handles));`
	`45`	`+ Task<bool> t = Task.Run(() => WaitHandle.WaitAll(handles, FailedWaitTimeout));`
`44`	`46`	`for (int i = 0; i < handles.Length; i++)`
`45`	`47`	`{`
`46`	`48`	`Assert.False(t.IsCompleted);`
`@@ -58,7 +60,7 @@ public void WaitHandleWaitAny()`
`58`	`60`	`for (int i = 0; i < handles.Length; i++)`
`59`	`61`	`handles[i] = new AutoResetEvent(false);`
`60`	`62`
`61`		`- Task<int> t = Task.Run(() => WaitHandle.WaitAny(handles));`
	`63`	`+ Task<int> t = Task.Run(() => WaitHandle.WaitAny(handles, FailedWaitTimeout));`
`62`	`64`	`handles[5].Set();`
`63`	`65`	`Assert.Equal(5, t.Result);`
`64`	`66`
`@@ -76,15 +78,15 @@ public void PingPong()`
`76`	`78`	`{`
`77`	`79`	`for (int i = 0; i < Iters; i++)`
`78`	`80`	`{`
`79`		`- Assert.True(are1.WaitOne());`
	`81`	`+ Assert.True(are1.WaitOne(FailedWaitTimeout));`
`80`	`82`	`are2.Set();`
`81`	`83`	`}`
`82`	`84`	`}, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default),`
`83`	`85`	`Task.Factory.StartNew(() =>`
`84`	`86`	`{`
`85`	`87`	`for (int i = 0; i < Iters; i++)`
`86`	`88`	`{`
`87`		`- Assert.True(are2.WaitOne());`
	`89`	`+ Assert.True(are2.WaitOne(FailedWaitTimeout));`
`88`	`90`	`are1.Set();`
`89`	`91`	`}`
`90`	`92`	`}, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default));`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,8 @@`
`8`	`8`
`9`	`9`	`public class ManualResetEventTests`
`10`	`10`	`{`
	`11`	`+ private const int FailedWaitTimeout = 30000;`
	`12`	`+`
`11`	`13`	`[Fact]`
`12`	`14`	`public void Ctor()`
`13`	`15`	`{`
`@@ -41,7 +43,7 @@ public void WaitHandleWaitAll()`
`41`	`43`	`for (int i = 0; i < handles.Length; i++)`
`42`	`44`	`handles[i] = new ManualResetEvent(false);`
`43`	`45`
`44`		`- Task<bool> t = Task.Run(() => WaitHandle.WaitAll(handles));`
	`46`	`+ Task<bool> t = Task.Run(() => WaitHandle.WaitAll(handles, FailedWaitTimeout));`
`45`	`47`	`for (int i = 0; i < handles.Length; i++)`
`46`	`48`	`{`
`47`	`49`	`Assert.False(t.IsCompleted);`
`@@ -59,7 +61,7 @@ public void WaitHandleWaitAny()`
`59`	`61`	`for (int i = 0; i < handles.Length; i++)`
`60`	`62`	`handles[i] = new ManualResetEvent(false);`
`61`	`63`
`62`		`- Task<int> t = Task.Run(() => WaitHandle.WaitAny(handles));`
	`64`	`+ Task<int> t = Task.Run(() => WaitHandle.WaitAny(handles, FailedWaitTimeout));`
`63`	`65`	`handles[5].Set();`
`64`	`66`	`Assert.Equal(5, t.Result);`
`65`	`67`
`@@ -77,7 +79,7 @@ public void PingPong()`
`77`	`79`	`{`
`78`	`80`	`for (int i = 0; i < Iters; i++)`
`79`	`81`	`{`
`80`		`- Assert.True(mre1.WaitOne());`
	`82`	`+ Assert.True(mre1.WaitOne(FailedWaitTimeout));`
`81`	`83`	`mre1.Reset();`
`82`	`84`	`mre2.Set();`
`83`	`85`	`}`
`@@ -86,7 +88,7 @@ public void PingPong()`
`86`	`88`	`{`
`87`	`89`	`for (int i = 0; i < Iters; i++)`
`88`	`90`	`{`
`89`		`- Assert.True(mre2.WaitOne());`
	`91`	`+ Assert.True(mre2.WaitOne(FailedWaitTimeout));`
`90`	`92`	`mre2.Reset();`
`91`	`93`	`mre1.Set();`
`92`	`94`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,24 +8,26 @@`
`8`	`8`
`9`	`9`	`public class MutexTests`
`10`	`10`	`{`
	`11`	`+ private const int FailedWaitTimeout = 30000;`
	`12`	`+`
`11`	`13`	`[Fact]`
`12`	`14`	`public void Ctor_ConstructWaitRelease()`
`13`	`15`	`{`
`14`	`16`	`using (Mutex m = new Mutex())`
`15`	`17`	`{`
`16`		`- Assert.True(m.WaitOne());`
	`18`	`+ Assert.True(m.WaitOne(FailedWaitTimeout));`
`17`	`19`	`m.ReleaseMutex();`
`18`	`20`	`}`
`19`	`21`
`20`	`22`	`using (Mutex m = new Mutex(false))`
`21`	`23`	`{`
`22`		`- Assert.True(m.WaitOne());`
	`24`	`+ Assert.True(m.WaitOne(FailedWaitTimeout));`
`23`	`25`	`m.ReleaseMutex();`
`24`	`26`	`}`
`25`	`27`
`26`	`28`	`using (Mutex m = new Mutex(true))`
`27`	`29`	`{`
`28`		`- Assert.True(m.WaitOne());`
	`30`	`+ Assert.True(m.WaitOne(FailedWaitTimeout));`
`29`	`31`	`m.ReleaseMutex();`
`30`	`32`	`m.ReleaseMutex();`
`31`	`33`	`}`
`@@ -86,11 +88,11 @@ public void OpenExisting_Windows()`
`86`	`88`	`{`
`87`	`89`	`using (Mutex m2 = Mutex.OpenExisting(name))`
`88`	`90`	`{`
`89`		`- Assert.True(m1.WaitOne());`
	`91`	`+ Assert.True(m1.WaitOne(FailedWaitTimeout));`
`90`	`92`	`Assert.False(Task.Factory.StartNew(() => m2.WaitOne(0), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default).Result);`
`91`	`93`	`m1.ReleaseMutex();`
`92`	`94`
`93`		`- Assert.True(m2.WaitOne());`
	`95`	`+ Assert.True(m2.WaitOne(FailedWaitTimeout));`
`94`	`96`	`Assert.False(Task.Factory.StartNew(() => m1.WaitOne(0), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default).Result);`
`95`	`97`	`m2.ReleaseMutex();`
`96`	`98`	`}`
`@@ -106,14 +108,23 @@ public void AbandonExisting()`
`106`	`108`	`{`
`107`	`109`	`using (Mutex m = new Mutex())`
`108`	`110`	`{`
`109`		`- Task.Factory.StartNew(() => m.WaitOne(), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default).Wait();`
`110`		`- Assert.Throws<AbandonedMutexException>(() => m.WaitOne());`
	`111`	`+ Task t = Task.Factory.StartNew(() =>`
	`112`	`+ {`
	`113`	`+ Assert.True(m.WaitOne(FailedWaitTimeout));`
	`114`	`+ // don't release the mutex; abandon it on this thread`
	`115`	`+ }, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);`
	`116`	`+ t.Wait();`
	`117`	`+ Assert.Throws<AbandonedMutexException>(() => m.WaitOne(FailedWaitTimeout));`
`111`	`118`	`}`
`112`	`119`
`113`	`120`	`using (Mutex m = new Mutex())`
`114`	`121`	`{`
`115`		`- Task.Factory.StartNew(() => m.WaitOne(), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default).Wait();`
`116`		`- AbandonedMutexException ame = Assert.Throws<AbandonedMutexException>(() => WaitHandle.WaitAny(new[] { m }));`
	`122`	`+ Task t = Task.Factory.StartNew(() =>`
	`123`	`+ {`
	`124`	`+ Assert.True(m.WaitOne(FailedWaitTimeout));`
	`125`	`+ }, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);`
	`126`	`+ t.Wait();`
	`127`	`+ AbandonedMutexException ame = Assert.Throws<AbandonedMutexException>(() => WaitHandle.WaitAny(new[] { m }, FailedWaitTimeout));`
`117`	`128`	`Assert.Equal(0, ame.MutexIndex);`
`118`	`129`	`}`
`119`	`130`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,8 @@ namespace Test`
`10`	`10`	`{`
`11`	`11`	`public class SemaphoreTests`
`12`	`12`	`{`
	`13`	`+ private const int FailedWaitTimeout = 30000;`
	`14`	`+`
`13`	`15`	`[Theory]`
`14`	`16`	`[InlineData(0, 1)]`
`15`	`17`	`[InlineData(1, 1)]`
`@@ -154,7 +156,7 @@ public void AnonymousProducerConsumer()`
`154`	`156`	`Task.Factory.StartNew(() =>`
`155`	`157`	`{`
`156`	`158`	`for (int i = 0; i < NumItems; i++)`
`157`		`- s.WaitOne();`
	`159`	`+ Assert.True(s.WaitOne(FailedWaitTimeout));`
`158`	`160`	`Assert.False(s.WaitOne(0));`
`159`	`161`	`}, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default),`
`160`	`162`	`Task.Factory.StartNew(() =>`
`@@ -169,21 +171,21 @@ public void AnonymousProducerConsumer()`
`169`	`171`	`[Fact]`
`170`	`172`	`public void NamedProducerConsumer()`
`171`	`173`	`{`
`172`		`- const string Name = "NamedProducerConsumerSemaphoreTest";`
	`174`	`+ string name = Guid.NewGuid().ToString("N");`
`173`	`175`	`const int NumItems = 5;`
`174`	`176`	`Task.WaitAll(`
`175`	`177`	`Task.Factory.StartNew(() =>`
`176`	`178`	`{`
`177`		`- using (Semaphore s = new Semaphore(0, Int32.MaxValue, Name))`
	`179`	`+ using (Semaphore s = new Semaphore(0, Int32.MaxValue, name))`
`178`	`180`	`{`
`179`	`181`	`for (int i = 0; i < NumItems; i++)`
`180`		`- s.WaitOne();`
	`182`	`+ Assert.True(s.WaitOne(1000));`
`181`	`183`	`Assert.False(s.WaitOne(0));`
`182`	`184`	`}`
`183`	`185`	`}, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default),`
`184`	`186`	`Task.Factory.StartNew(() =>`
`185`	`187`	`{`
`186`		`- using (Semaphore s = new Semaphore(0, Int32.MaxValue, Name))`
	`188`	`+ using (Semaphore s = new Semaphore(0, Int32.MaxValue, name))`
`187`	`189`	`{`
`188`	`190`	`for (int i = 0; i < NumItems; i++)`
`189`	`191`	`s.Release();`