Fix some named mutex tests

Related to dotnet/coreclr#5030
Related to dotnet/coreclr#3422

src/System.Threading/tests/MutexTests.cs

@@ -4,6 +4,7 @@
 
 using System.Diagnostics;
 using System.IO;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using Xunit;
 
@@ -36,16 +37,14 @@ public void Ctor_ConstructWaitRelease()
             }
         }
 
-        [PlatformSpecific(PlatformID.Windows)]
         [Fact]
         public void Ctor_InvalidName()
         {
             Assert.Throws<ArgumentException>(() => new Mutex(false, new string('a', 1000)));
         }
 
-        [PlatformSpecific(PlatformID.Windows)]
         [Fact]
-        public void Ctor_ValidName_Windows()
+        public void Ctor_ValidName()
         {
             string name = Guid.NewGuid().ToString("N");
             bool createdNew;
@@ -70,9 +69,8 @@ public void Ctor_NameUsedByOtherSynchronizationPrimitive_Windows()
             }
         }
 
-        [PlatformSpecific(PlatformID.Windows)]
         [Fact]
-        public void OpenExisting_Windows()
+        public void OpenExisting()
         {
             string name = Guid.NewGuid().ToString("N");
 
@@ -98,18 +96,16 @@ public void OpenExisting_Windows()
             }
         }
 
-        [PlatformSpecific(PlatformID.Windows)]
         [Fact]
-        public void OpenExisting_InvalidNames_Windows()
+        public void OpenExisting_InvalidNames()
         {
             Assert.Throws<ArgumentNullException>("name", () => Mutex.OpenExisting(null));
             Assert.Throws<ArgumentException>(() => Mutex.OpenExisting(string.Empty));
             Assert.Throws<ArgumentException>(() => Mutex.OpenExisting(new string('a', 10000)));
         }
 
-        [PlatformSpecific(PlatformID.Windows)]
         [Fact]
-        public void OpenExisting_UnavailableName_Windows()
+        public void OpenExisting_UnavailableName()
         {
             string name = Guid.NewGuid().ToString("N");
             Assert.Throws<WaitHandleCannotBeOpenedException>(() => Mutex.OpenExisting(name));
@@ -130,28 +126,56 @@ public void OpenExisting_NameUsedByOtherSynchronizationPrimitive_Windows()
             }
         }
 
-        [Fact]
-        public void AbandonExisting()
+        public static IEnumerable<object[]> AbandonExisting_MemberData()
         {
-            using (Mutex m = new Mutex())
+            var nameGuidStr = Guid.NewGuid().ToString("N");
+            foreach (var isNamed in new[] { false, true })
             {
-                Task t = Task.Factory.StartNew(() =>
+                for (int waitType = 0; waitType < 3; ++waitType) // 0 == WaitOne, 1 == WaitAny, 2 == WaitAll
                 {
-                    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));
+                    if (isNamed)
+                    {
+                        foreach (var namePrefix in new[] { string.Empty, "Local\\", "Global\\" })
+                        {
+                            yield return new object[] { namePrefix + nameGuidStr, waitType };
+                        }
+                    }
+                    else
+                    {
+                        yield return new object[] { null, waitType };
+                    }
+                }
             }
+        }
 
-            using (Mutex m = new Mutex())
+        [Theory]
+        [MemberData(nameof(AbandonExisting_MemberData))]
+        public void AbandonExisting(string name, int waitType)
+        {
+            using (var m = new Mutex(false, name))
             {
                 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();
-                AbandonedMutexException ame = Assert.Throws<AbandonedMutexException>(() => WaitHandle.WaitAny(new[] { m }, FailedWaitTimeout));
+
+                AbandonedMutexException ame;
+                switch (waitType)
+                {
+                    case 0: // WaitOne
+                        Assert.Throws<AbandonedMutexException>(() => m.WaitOne(FailedWaitTimeout));
+                        return;
+
+                    case 1: // WaitAny
+                        ame = Assert.Throws<AbandonedMutexException>(() => WaitHandle.WaitAny(new[] { m }, FailedWaitTimeout));
+                        break;
+
+                    case 2: // WaitAll
+                        ame = Assert.Throws<AbandonedMutexException>(() => WaitHandle.WaitAll(new[] { m }, FailedWaitTimeout));
+                        break;
+                }
                 Assert.Equal(0, ame.MutexIndex);
                 Assert.Equal(m, ame.Mutex);
             }