Merge pull request #900 from Blewzman/FixAggregateExceptionGetBaseException

[mono.git] / mcs / class / corlib / Test / System.Threading / AutoResetEventTest.cs

diff --git a/mcs/class/corlib/Test/System.Threading/AutoResetEventTest.cs b/mcs/class/corlib/Test/System.Threading/AutoResetEventTest.cs
index 95dfe2312440d770edf79c452b12c9d80e2689d8..df0a77631c48df292285e3825469656dbaae39a0 100644 (file)
--- a/mcs/class/corlib/Test/System.Threading/AutoResetEventTest.cs
+++ b/mcs/class/corlib/Test/System.Threading/AutoResetEventTest.cs
@@ -3,7 +3,7 @@
 //
 // Author:
 //     Gonzalo Paniagua Javier (gonzalo@ximian.com)
-//      Gert Driesen <gert.driesen@telenet.be>
+//     Gert Driesen <gert.driesen@telenet.be>
 //
 // Copyright 2005 Novell, Inc (http://www.novell.com)
 // Copyright 2007 Gert Driesen
@@ -16,111 +16,105 @@ using System.Threading;
 using Microsoft.Win32.SafeHandles;
 #endif
 
-namespace MonoTests.System.Threading {
-
+namespace MonoTests.System.Threading
+{
        [TestFixture]
-       public class AutoResetEventTest : Assertion {
+       public class AutoResetEventTest
+       {
                [Test]
                public void MultipleSet ()
                {
                        AutoResetEvent evt = new AutoResetEvent (true);
-                       Assertion.AssertEquals ("#01", true, evt.WaitOne (1000, false));
+                       Assert.IsTrue (evt.WaitOne (1000, false), "#1");
                        evt.Set ();
                        evt.Set ();
-                       Assertion.AssertEquals ("#02", true, evt.WaitOne (1000, false));
-                       Assertion.AssertEquals ("#03", false, evt.WaitOne (1000, false));
+                       Assert.IsTrue (evt.WaitOne (1000, false), "#2");
+                       Assert.IsFalse (evt.WaitOne (1000, false), "#3");
                }
-       }
 
 #if NET_2_0
-       [TestFixture]
-       public class AutoResetEvent_SafeHandles : Assertion {
-
-               //
-               // Verifies that the safe SafeWaitHandle is used even when Handle is set
-               //
-               [Test]
-               public void SafeWaitHandleIdentity ()
+               [Test] // bug #81529
+               public void SafeWaitHandle ()
                {
                        AutoResetEvent are1 = new AutoResetEvent (false);
                        AutoResetEvent are2 = new AutoResetEvent (false);
                        SafeWaitHandle swh1 = are1.SafeWaitHandle;
-                       Assertion.AssertEquals ("#A1:", false, swh1.IsClosed);
-                       Assertion.AssertEquals ("#A2:", false, swh1.IsInvalid);
+                       SafeWaitHandle swh2 = are2.SafeWaitHandle;
+                       are1.SafeWaitHandle = are2.SafeWaitHandle;
+                       Assert.AreSame (are1.SafeWaitHandle, are2.SafeWaitHandle, "#1");
+                       Assert.AreEqual (are1.Handle, are2.Handle, "#2");
+                       Assert.IsFalse (are1.SafeWaitHandle.IsInvalid, "#3");
+                       Assert.IsFalse (are1.SafeWaitHandle.IsClosed, "#4");
+                       Assert.IsFalse (swh1.IsClosed, "#5");
+                       Assert.IsFalse (swh1.IsInvalid, "#6");
+                       swh1.Dispose ();
+                       are1.Close ();
+               }
+
+               [Test] // bug #81529
+               public void SafeWaitHandle_Null ()
+               {
+                       AutoResetEvent are1 = new AutoResetEvent (false);
+                       SafeWaitHandle swh1 = are1.SafeWaitHandle;
+                       are1.SafeWaitHandle = null;
+                       Assert.IsNotNull (are1.SafeWaitHandle, "#1");
+                       Assert.AreEqual (-1, (int) are1.Handle, "#2");
+                       Assert.IsTrue (are1.SafeWaitHandle.IsInvalid, "#3");
+                       Assert.IsFalse (are1.SafeWaitHandle.IsClosed, "#4");
+                       Assert.IsFalse (swh1.IsClosed, "#5");
+                       Assert.IsFalse (swh1.IsInvalid, "#6");
+               }
+
+               [Test] // bug #81529
+               // Causes a Attempting to unref unused handle 0x2 warning
+               [Category ("NotWorking")]
+               public void Handle_Valid ()
+               {
+                       AutoResetEvent are1 = new AutoResetEvent (false);
+                       SafeWaitHandle swh1 = are1.SafeWaitHandle;
+                       Assert.IsFalse (swh1.IsClosed, "#1");
+                       Assert.IsFalse (swh1.IsInvalid, "#2");
                        IntPtr dummyHandle = (IntPtr) 2;
                        are1.Handle = dummyHandle;
-                       Assertion.AssertEquals ("#A3:", true, (are1.Handle == dummyHandle));
-                       Assertion.AssertEquals ("#A4:", false, swh1.IsClosed);
-                       Assertion.AssertEquals ("#A5:", false, swh1.IsClosed);
-                       Assertion.AssertEquals ("#A6:", false, swh1.IsInvalid);
-                       Assertion.AssertEquals ("#A7:", false, are1.SafeWaitHandle.IsClosed);
-                       Assertion.AssertEquals ("#A8:", false, are1.SafeWaitHandle.IsInvalid);
+                       Assert.AreEqual (are1.Handle, dummyHandle, "#3");
+                       Assert.IsFalse (swh1.IsClosed, "#4");
+                       Assert.IsFalse (swh1.IsClosed, "#5");
+                       Assert.IsFalse (swh1.IsInvalid, "#6");
+                       Assert.IsFalse (are1.SafeWaitHandle.IsClosed, "#7");
+                       Assert.IsFalse (are1.SafeWaitHandle.IsInvalid, "#8");
                        are1.Close ();
-                       are2.Close ();
                        swh1.Dispose ();
                }
 
-               [Test]
-               public void Test2 ()
-               {
-                       AutoResetEvent are1 = new AutoResetEvent (false);
-                       are1.SafeWaitHandle = null;
-                       Assertion.AssertEquals ("#B1:", true, (are1.SafeWaitHandle != null));
-                       Assertion.AssertEquals ("#B2:", true, (((int) are1.Handle) == -1));
-                       Assertion.AssertEquals ("#B3:", true, are1.SafeWaitHandle.IsInvalid);
-                       Assertion.AssertEquals ("#B4:", false, are1.SafeWaitHandle.IsClosed);
-               }
-
-               [Test]
-               public void Test3 ()
-               {
-                       AutoResetEvent are1 = new AutoResetEvent (false);
-                       AutoResetEvent are2 = new AutoResetEvent (false);
-                       SafeWaitHandle swh1 = are1.SafeWaitHandle;
-                       SafeWaitHandle swh2 = are2.SafeWaitHandle;
-                       Assertion.AssertEquals ("#C1:", true,  (swh1 != swh2));
-                       Assertion.AssertEquals ("#C2:", true, (are1.SafeWaitHandle == swh1));
-                       are1.Handle = are2.Handle;
-                       Assertion.AssertEquals ("#C3:", true, (are1.SafeWaitHandle != swh1));
-                       Assertion.AssertEquals ("#C4:", false, swh1.IsClosed);
-                       Assertion.AssertEquals ("#C5:", false, swh1.IsInvalid);
-                       swh1.Dispose ();
-                       are1.Close ();
-                       are2.Close ();
-               }
-
-               [Test]
-               public void Test4 ()
-               {
-                       AutoResetEvent are1 = new AutoResetEvent (false);
-                       SafeWaitHandle swh1 = are1.SafeWaitHandle;
-                       are1.Handle = (IntPtr) (-1);
-                       Assertion.AssertEquals ("#D1:" , true, swh1 != are1.SafeWaitHandle);
-                       Assertion.AssertEquals ("#D2:" , false, are1.SafeWaitHandle.IsClosed);
-                       Assertion.AssertEquals ("#D3:" , true, are1.SafeWaitHandle.IsInvalid);
-                       are1.Close ();
-                       swh1.Dispose ();
-               }
+               [Test] // bug #81529
+               public void Handle_Invalid ()
+               {
+                       AutoResetEvent are1 = new AutoResetEvent (false);
+                       SafeWaitHandle swh1 = are1.SafeWaitHandle;
+                       are1.Handle = (IntPtr) (-1);
+                       Assert.IsTrue (swh1 != are1.SafeWaitHandle, "#1");
+                       Assert.IsFalse (swh1.IsClosed, "#2");
+                       Assert.IsFalse (swh1.IsInvalid, "#3");
+                       Assert.IsFalse (are1.SafeWaitHandle.IsClosed, "#4");
+                       Assert.IsTrue (are1.SafeWaitHandle.IsInvalid, "#5");
+                       are1.Close ();
+                       swh1.Dispose ();
+               }
 
-               [Test]
-               public void Test5 ()
-               {
-                       AutoResetEvent are1 = new AutoResetEvent (false);
-                       AutoResetEvent are2 = new AutoResetEvent (false);
-       
-                       SafeWaitHandle swh1 = are1.SafeWaitHandle;
-                       Assertion.AssertEquals ("#E1:", false, swh1.IsClosed);
-                       Assertion.AssertEquals ("#E2:", false, swh1.IsInvalid);
-                       are1.Handle = IntPtr.Zero;
-                       Assertion.AssertEquals ("#E3:", false, swh1.IsClosed);
-                       Assertion.AssertEquals ("#E4:", false, swh1.IsInvalid);
-                       Assertion.AssertEquals ("#E5:", false, are1.SafeWaitHandle.IsClosed);
-                       Assertion.AssertEquals ("#E6:", true, are1.SafeWaitHandle.IsInvalid);
-                       are1.Close ();
-                       are2.Close ();
-                       swh1.Dispose ();
-               }
-       }
+               [Test] // bug #81529
+               public void Handle_ZeroPtr ()
+               {
+                       AutoResetEvent are1 = new AutoResetEvent (false);
+                       SafeWaitHandle swh1 = are1.SafeWaitHandle;
+                       are1.Handle = IntPtr.Zero;
+                       Assert.IsTrue (swh1 != are1.SafeWaitHandle, "#1");
+                       Assert.IsFalse (swh1.IsClosed, "#2");
+                       Assert.IsFalse (swh1.IsInvalid, "#3");
+                       Assert.IsFalse (are1.SafeWaitHandle.IsClosed, "#4");
+                       Assert.IsTrue (are1.SafeWaitHandle.IsInvalid, "#5");
+                       are1.Close ();
+                       swh1.Dispose ();
+               }
 #endif
+       }
 }
-