Merge pull request #2830 from stephentoub/threading_deadlock_tests

stephentoub · stephentoub · commit 54f98dd719ac · 2015-08-15T17:34:55.000-04:00
Avoid test deadlocks in threading WaitHandle tests
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,22 +171,25 @@ public void AnonymousProducerConsumer()
         [Fact]
         public void NamedProducerConsumer()
         {
-            const string Name = "NamedProducerConsumerSemaphoreTest";
+            string name = Guid.NewGuid().ToString("N");
             const int NumItems = 5;
+            var b = new Barrier(2);
             Task.WaitAll(
                 Task.Factory.StartNew(() =>
                 {
-                    using (Semaphore s = new Semaphore(0, Int32.MaxValue, Name))
+                    using (var s = new Semaphore(0, int.MaxValue, name))
                     {
+                        Assert.True(b.SignalAndWait(FailedWaitTimeout));
                         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(() =>
                 {
-                    using (Semaphore s = new Semaphore(0, Int32.MaxValue, Name))
+                    using (var s = new Semaphore(0, int.MaxValue, name))
                     {
+                        Assert.True(b.SignalAndWait(FailedWaitTimeout));
                         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,22 +171,25 @@ 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;`
	`176`	`+ var b = new Barrier(2);`
`174`	`177`	`Task.WaitAll(`
`175`	`178`	`Task.Factory.StartNew(() =>`
`176`	`179`	`{`
`177`		`- using (Semaphore s = new Semaphore(0, Int32.MaxValue, Name))`
	`180`	`+ using (var s = new Semaphore(0, int.MaxValue, name))`
`178`	`181`	`{`
	`182`	`+ Assert.True(b.SignalAndWait(FailedWaitTimeout));`
`179`	`183`	`for (int i = 0; i < NumItems; i++)`
`180`		`- s.WaitOne();`
	`184`	`+ Assert.True(s.WaitOne(FailedWaitTimeout));`
`181`	`185`	`Assert.False(s.WaitOne(0));`
`182`	`186`	`}`
`183`	`187`	`}, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default),`
`184`	`188`	`Task.Factory.StartNew(() =>`
`185`	`189`	`{`
`186`		`- using (Semaphore s = new Semaphore(0, Int32.MaxValue, Name))`
	`190`	`+ using (var s = new Semaphore(0, int.MaxValue, name))`
`187`	`191`	`{`
	`192`	`+ Assert.True(b.SignalAndWait(FailedWaitTimeout));`
`188`	`193`	`for (int i = 0; i < NumItems; i++)`
`189`	`194`	`s.Release();`
`190`	`195`	`}`