Author: gert
Date: 2007-07-22 02:57:28 -0400 (Sun, 22 Jul 2007)
New Revision: 82427

Modified:
   trunk/mcs/class/corlib/Test/System.Threading/AutoResetEventTest.cs
   trunk/mcs/class/corlib/Test/System.Threading/ChangeLog
Log:
* AutoResetEventTest.cs: Added test for verifying effect of assigning 
new SafeWaitHandle on the previous one. Use meaningful names for
tests. Avoid unref warning. Removed usage of deprecated Assertion
class. Spaces to tabs.


Modified: trunk/mcs/class/corlib/Test/System.Threading/AutoResetEventTest.cs
===================================================================
--- trunk/mcs/class/corlib/Test/System.Threading/AutoResetEventTest.cs  
2007-07-22 06:54:05 UTC (rev 82426)
+++ trunk/mcs/class/corlib/Test/System.Threading/AutoResetEventTest.cs  
2007-07-22 06:57:28 UTC (rev 82427)
@@ -3,7 +3,7 @@
 //
 // Author:
 //     Gonzalo Paniagua Javier ([EMAIL PROTECTED])
-//      Gert Driesen <[EMAIL PROTECTED]>
+//     Gert Driesen <[EMAIL PROTECTED]>
 //
 // Copyright 2005 Novell, Inc (http://www.novell.com)
 // Copyright 2007 Gert Driesen
@@ -16,111 +16,103 @@
 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
+               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] // 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 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]
-               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
+       }
 }
-

Modified: trunk/mcs/class/corlib/Test/System.Threading/ChangeLog
===================================================================
--- trunk/mcs/class/corlib/Test/System.Threading/ChangeLog      2007-07-22 
06:54:05 UTC (rev 82426)
+++ trunk/mcs/class/corlib/Test/System.Threading/ChangeLog      2007-07-22 
06:57:28 UTC (rev 82427)
@@ -1,3 +1,10 @@
+2007-07-22  Gert Driesen  <[EMAIL PROTECTED]>
+
+       * AutoResetEventTest.cs: Added test for verifying effect of assigning
+       new SafeWaitHandle on the previous one. Use meaningful names for
+       tests. Avoid unref warning. Removed usage of deprecated Assertion
+       class. Spaces to tabs.
+
 2007-07-21  Miguel de Icaza  <[EMAIL PROTECTED]>
 
        * AutoResetEventTest.cs: Integrated test based on Gert's email

_______________________________________________
Mono-patches maillist  -  [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches

Reply via email to