X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fclass%2Fcorlib%2FTest%2FSystem.Threading%2FThreadTest.cs;h=db21332f30c8b81f8c71a1bf242dd3ba4e55c2ba;hb=beb8d0c0df62c6bf6d9b3672c32f52ec9b358da6;hp=92804b278829735e47741ab1cb1691fc3c3b179d;hpb=ca1ca15642673854814f48dc4bef71dbb0f7a97c;p=mono.git

diff --git a/mcs/class/corlib/Test/System.Threading/ThreadTest.cs b/mcs/class/corlib/Test/System.Threading/ThreadTest.cs
index 92804b27882..db21332f30c 100644
--- a/mcs/class/corlib/Test/System.Threading/ThreadTest.cs
+++ b/mcs/class/corlib/Test/System.Threading/ThreadTest.cs
@@ -9,44 +9,52 @@
 // (C) 2004 Novell (http://www.novell.com)
 //
 
-using NUnit.Framework;
 using System;
+using System.Globalization;
 using System.Security.Principal;
 using System.Threading;
 
-namespace MonoTests.System.Threading {
-
-	public class ThreadedPrincipalTest : Assertion {
+using NUnit.Framework;
 
+namespace MonoTests.System.Threading
+{
+	// These tests seem to hang the 2.0 framework. So they are disabled for now
+	// Don't reenable them until you can run a few thousand times on an SMP box.
+	[Category ("NotWorking")]
+	public class ThreadedPrincipalTest
+	{
 		public static void NoPrincipal () 
 		{
+#if !TARGET_JVM // AppDomain.SetPrincipalPolicy not supported for TARGET_JVM
 			AppDomain.CurrentDomain.SetPrincipalPolicy (PrincipalPolicy.NoPrincipal);
+#endif
 			IPrincipal p = Thread.CurrentPrincipal;
-			AssertNull ("Thread.CurrentPrincipal-1", p);
+			Assert.IsNull (p, "#1");
 
 			Thread.CurrentPrincipal = new GenericPrincipal (new GenericIdentity ("mono"), null);
-			AssertNotNull ("Thread.CurrentPrincipal-2", Thread.CurrentPrincipal);
+			Assert.IsNotNull (Thread.CurrentPrincipal, "#2");
 
 			Thread.CurrentPrincipal = null;
-			AssertNull ("Thread.CurrentPrincipal-3", Thread.CurrentPrincipal);
+			Assert.IsNull (Thread.CurrentPrincipal, "#3");
 			// in this case we can return to null
 		}
 
+#if !TARGET_JVM // AppDomain.SetPrincipalPolicy not supported for TARGET_JVM
 		public static void UnauthenticatedPrincipal () 
 		{
 			AppDomain.CurrentDomain.SetPrincipalPolicy (PrincipalPolicy.UnauthenticatedPrincipal);
 			IPrincipal p = Thread.CurrentPrincipal;
-			AssertNotNull ("Thread.CurrentPrincipal", p);
-			Assert ("Type", (p is GenericPrincipal));
-			AssertEquals ("Name", String.Empty, p.Identity.Name);
-			AssertEquals ("AuthenticationType", String.Empty, p.Identity.AuthenticationType);
-			Assert ("IsAuthenticated", !p.Identity.IsAuthenticated);
+			Assert.IsNotNull (p, "#1");
+			Assert.IsTrue ((p is GenericPrincipal), "#2");
+			Assert.AreEqual (String.Empty, p.Identity.Name, "#3");
+			Assert.AreEqual (String.Empty, p.Identity.AuthenticationType, "#4");
+			Assert.IsFalse (p.Identity.IsAuthenticated, "#5");
 
 			Thread.CurrentPrincipal = new GenericPrincipal (new GenericIdentity ("mono"), null);
-			AssertNotNull ("Thread.CurrentPrincipal-2", Thread.CurrentPrincipal);
+			Assert.IsNotNull (Thread.CurrentPrincipal, "#6");
 
 			Thread.CurrentPrincipal = null;
-			AssertNotNull ("Thread.CurrentPrincipal-3", Thread.CurrentPrincipal);
+			Assert.IsNotNull (Thread.CurrentPrincipal, "#7");
 			// in this case we can't return to null
 		}
 
@@ -54,25 +62,33 @@ namespace MonoTests.System.Threading {
 		{
 			AppDomain.CurrentDomain.SetPrincipalPolicy (PrincipalPolicy.WindowsPrincipal);
 			IPrincipal p = Thread.CurrentPrincipal;
-			AssertNotNull ("Thread.CurrentPrincipal", p);
-			Assert ("Type", (p is WindowsPrincipal));
-			AssertNotNull ("Name", p.Identity.Name);
-			AssertNotNull ("AuthenticationType", p.Identity.AuthenticationType);
-			Assert ("IsAuthenticated", p.Identity.IsAuthenticated);
+			Assert.IsNotNull (p, "#1");
+			Assert.IsTrue ((p is WindowsPrincipal), "#2");
+			Assert.IsNotNull (p.Identity.Name, "#3");
+			Assert.IsNotNull (p.Identity.AuthenticationType, "#4");
+			Assert.IsTrue (p.Identity.IsAuthenticated, "#5");
 
 			// note: we can switch from a WindowsPrincipal to a GenericPrincipal
 			Thread.CurrentPrincipal = new GenericPrincipal (new GenericIdentity ("mono"), null);
-			AssertNotNull ("Thread.CurrentPrincipal-2", Thread.CurrentPrincipal);
+			Assert.IsNotNull (Thread.CurrentPrincipal, "#6");
 
 			Thread.CurrentPrincipal = null;
-			AssertNotNull ("Thread.CurrentPrincipal-3", Thread.CurrentPrincipal);
+			Assert.IsNotNull (Thread.CurrentPrincipal, "#7");
 			// in this case we can't return to null
 		}
+#endif // TARGET_JVM
+
+		public static void CopyOnNewThread ()
+		{
+			Assert.IsNotNull (Thread.CurrentPrincipal, "#1");
+			Assert.AreEqual ("good", Thread.CurrentPrincipal.Identity.Name, "#2");
+		}
 	}
 
 	[TestFixture]
-	public class ThreadTest : Assertion {
-
+	[Category ("NotWorking")]
+	public class ThreadTest
+	{
 		//Some Classes to test as threads
 		private class C1Test
 		{
@@ -143,6 +159,7 @@ namespace MonoTests.System.Threading {
 			public void TestMethod1()
 			{
 				sub_thread.Start();
+				Thread.Sleep (100);
 				sub_thread.Abort();
 			}
 		}
@@ -169,16 +186,16 @@ namespace MonoTests.System.Threading {
 			public void TestMethod1()
 			{
 				thread1.Start();
-				while (!thread1.IsAlive);
+				TestUtil.WaitForAlive (thread1, "wait1");
 				T1ON = true;
 				thread2.Start();
-				while (!thread2.IsAlive);
+				TestUtil.WaitForAlive (thread2, "wait2");
 				T2ON = true;
 				thread1.Abort();
-				while (thread1.IsAlive);
+				TestUtil.WaitForNotAlive (thread1, "wait3");
 				T1ON = false;
 				thread2.Abort();
-				while (thread2.IsAlive);
+				TestUtil.WaitForNotAlive (thread2, "wait4");
 				T2ON = false;
 			}
 			
@@ -195,13 +212,14 @@ namespace MonoTests.System.Threading {
 			try
 			{
 				Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
-			}
-			catch (Exception e)
+			}
+			catch (Exception e)
 			{
-				Fail ("#01 Unexpected Exception Thrown: " + e.ToString ());
+				Assert.Fail ("#01 Unexpected Exception Thrown: " + e.ToString ());
 			}
 		}
 
+		[Category("NotDotNet")]
 		public void TestStart()
 		{
 		{
@@ -210,13 +228,13 @@ namespace MonoTests.System.Threading {
 			try
 			{
 				TestThread.Start();
-			}
-			catch (Exception e)
+			}
+			catch (Exception e)
 			{
-				Fail ("#12 Unexpected Exception Thrown: " + e.ToString ());
+				Assert.Fail ("#12 Unexpected Exception Thrown: " + e.ToString ());
 			}
 			TestThread.Join();
-			AssertEquals("#13 Thread Not started: ", 10,test1.cnt);
+			Assert.AreEqual (10, test1.cnt, "#13 Thread Not started");
 		}
 		{
 			bool errorThrown = false;
@@ -227,12 +245,12 @@ namespace MonoTests.System.Threading {
 			try
 			{
 				TestThread.Start();
-			}
-			catch(ThreadStateException)
+			}
+			catch(ThreadStateException)
 			{
 				errorThrown = true;
 			}
-			Assert ("#14 no ThreadStateException trown", errorThrown);
+			Assert.IsTrue (errorThrown, "#14 no ThreadStateException trown");
 		}
 		{
 			C2Test test1 = new C2Test();
@@ -240,7 +258,7 @@ namespace MonoTests.System.Threading {
 			TestThread.Start();
 			while(!test1.run);
 			bool started = (TestThread.ThreadState == ThreadState.Running);
-			AssertEquals("#15 Thread Is not in the correct state: ", started , test1.run);	
+			Assert.AreEqual (started, test1.run, "#15 Thread Is not in the correct state: ");
 			TestThread.Abort();
 		}
 		}
@@ -251,78 +269,104 @@ namespace MonoTests.System.Threading {
 			Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
 			ApartmentState before = TestThread.ApartmentState;
 			TestThread.Start();
-			while(!TestThread.IsAlive);
+			TestUtil.WaitForAlive (TestThread, "wait5");
 			ApartmentState after = TestThread.ApartmentState;
 			TestThread.Abort();
-			AssertEquals("#21 Apartment State Changed when not needed",before,after);
+			Assert.AreEqual (before, after, "#21 Apartment State Changed when not needed");
 		}
 
+		[Category("NotDotNet")]
 		public void TestApartmentState()
 		{
 			C2Test test1 = new C2Test();
 			Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
 			ApartmentState before = TestThread.ApartmentState;
 			TestThread.Start();
-			while(!TestThread.IsAlive);
+			TestUtil.WaitForAlive (TestThread, "wait6");
 			ApartmentState after = TestThread.ApartmentState;
 			TestThread.Abort();
-			AssertEquals("#31 Apartment State Changed when not needed: ",before,after);
+			Assert.AreEqual (before, after, "#31 Apartment State Changed when not needed: ");
 		}
 
 		public void TestPriority1()
 		{
 			C2Test test1 = new C2Test();
 			Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
-			TestThread.Priority=ThreadPriority.BelowNormal;
-			ThreadPriority after = TestThread.Priority;
-			TestThread.Start();
-			while(!TestThread.IsAlive);
-			ThreadPriority before = TestThread.Priority;
-			TestThread.Abort();
-			AssertEquals("#41 Unexpected Priority Change: ",before,after);
+			try {
+				TestThread.Priority=ThreadPriority.BelowNormal;
+				ThreadPriority after = TestThread.Priority;
+				TestThread.Start();
+				TestUtil.WaitForAlive (TestThread, "wait7");
+				ThreadPriority before = TestThread.Priority;
+				Assert.AreEqual (before, after, "#41 Unexpected Priority Change: ");
+			}
+			finally {
+				TestThread.Abort();
+			}
+		}
+
+		[Test]
+		public void AbortUnstarted ()
+		{
+			C2Test test1 = new C2Test();
+			Thread th = new Thread (new ThreadStart (test1.TestMethod));
+			th.Abort ();
+			th.Start ();
 		}
 
+		[Category("NotWorking")] // this is a MonoTODO -> no support for Priority
 		public void TestPriority2()
 		{
 			C2Test test1 = new C2Test();
 			Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
-			AssertEquals("#42 Incorrect Priority in New thread: ",ThreadPriority.Normal, TestThread.Priority);
-			TestThread.Start();
-			while(!TestThread.IsAlive);
-			AssertEquals("#43 Incorrect Priority in Started thread: ",ThreadPriority.Normal, TestThread.Priority);
-			TestThread.Abort();
-			AssertEquals("#44 Incorrect Priority in Aborted thread: ",ThreadPriority.Normal, TestThread.Priority);
+			try {
+				Assert.AreEqual (ThreadPriority.Normal, TestThread.Priority, "#42 Incorrect Priority in New thread: ");
+				TestThread.Start();
+				TestUtil.WaitForAliveOrStop (TestThread, "wait8");
+				Assert.AreEqual (ThreadPriority.Normal, TestThread.Priority, "#43 Incorrect Priority in Started thread: ");
+			}
+			finally {
+				TestThread.Abort();
+			}
+			Assert.AreEqual (ThreadPriority.Normal, TestThread.Priority, "#44 Incorrect Priority in Aborted thread: ");
 		}
 
+		[Category("NotWorking")] // this is a MonoTODO -> no support for Priority
 		public void TestPriority3()
 		{
-			
 			C2Test test1 = new C2Test();
 			Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
-			TestThread.Start();
-			TestThread.Priority = ThreadPriority.Lowest;
-			AssertEquals("#45A Incorrect Priority:",ThreadPriority.Lowest,TestThread.Priority);
-			TestThread.Priority = ThreadPriority.BelowNormal;
-			AssertEquals("#45B Incorrect Priority:",ThreadPriority.BelowNormal,TestThread.Priority);
-			TestThread.Priority = ThreadPriority.Normal;
-			AssertEquals("#45C Incorrect Priority:",ThreadPriority.Normal,TestThread.Priority);
-			TestThread.Priority = ThreadPriority.AboveNormal;
-			AssertEquals("#45D Incorrect Priority:",ThreadPriority.AboveNormal,TestThread.Priority);
-			TestThread.Priority = ThreadPriority.Highest;
-			AssertEquals("#45E Incorrect Priority:",ThreadPriority.Highest,TestThread.Priority);
-			TestThread.Abort();
+			try {
+				TestThread.Start();
+				TestThread.Priority = ThreadPriority.Lowest;
+				Assert.AreEqual (ThreadPriority.Lowest, TestThread.Priority, "#45A Incorrect Priority:");
+				TestThread.Priority = ThreadPriority.BelowNormal;
+				Assert.AreEqual (ThreadPriority.BelowNormal, TestThread.Priority, "#45B Incorrect Priority:");
+				TestThread.Priority = ThreadPriority.Normal;
+				Assert.AreEqual (ThreadPriority.Normal, TestThread.Priority, "#45C Incorrect Priority:");
+				TestThread.Priority = ThreadPriority.AboveNormal;
+				Assert.AreEqual (ThreadPriority.AboveNormal, TestThread.Priority, "#45D Incorrect Priority:");
+				TestThread.Priority = ThreadPriority.Highest;
+				Assert.AreEqual (ThreadPriority.Highest, TestThread.Priority, "#45E Incorrect Priority:");
+			}
+			finally {
+				TestThread.Abort();
+			}
 		}
 
-
 		public void TestIsBackground1()
 		{
 			C2Test test1 = new C2Test();
 			Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
-			TestThread.Start();
-			while(!TestThread.IsAlive);
-			bool state = TestThread.IsBackground;
-			TestThread.Abort();
-			Assert("#51 IsBackground not set at the default state: ",!(state));
+			try {
+				TestThread.Start();
+				TestUtil.WaitForAlive (TestThread, "wait9");
+				bool state = TestThread.IsBackground;
+				Assert.IsFalse (state, "#51 IsBackground not set at the default state: ");
+			}
+			finally {
+				TestThread.Abort();
+			}
 		}
 
 		public void TestIsBackground2()
@@ -330,9 +374,13 @@ namespace MonoTests.System.Threading {
 			C2Test test1 = new C2Test();
 			Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
 			TestThread.IsBackground = true;
-			TestThread.Start();
-			TestThread.Abort();
-			Assert("#52 Is Background Changed ot Start ",TestThread.IsBackground);
+			try {
+				TestThread.Start();
+			}
+			finally {
+				TestThread.Abort();
+			}
+			Assert.IsTrue (TestThread.IsBackground, "#52 Is Background Changed ot Start ");
 		}
 
 
@@ -340,29 +388,34 @@ namespace MonoTests.System.Threading {
 		{
 			C2Test test1 = new C2Test();
 			Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
-			TestThread.Start();
-			while(!TestThread.IsAlive);
-			string name = TestThread.Name;
-			AssertEquals("#61 Name set when mustn't be set: ", name, (string)null);
-			string newname = "Testing....";
-			TestThread.Name = newname;
-			AssertEquals("#62 Name not set when must be set: ",TestThread.Name,newname);
-			TestThread.Abort();
+			try {
+				TestThread.Start();
+				TestUtil.WaitForAlive (TestThread, "wait10");
+				string name = TestThread.Name;
+				Assert.IsNull (name, "#61 Name set when mustn't be set: ");
+				string newname = "Testing....";
+				TestThread.Name = newname;
+				Assert.AreEqual (newname, TestThread.Name, "#62 Name not set when must be set: ");
+			}
+			finally {
+				TestThread.Abort();
+			}
 		}
 
+		[Category("NotDotNet")]
 		public void TestNestedThreads1()
 		{
 			C3Test  test1 = new C3Test();
 			Thread TestThread = new Thread(new ThreadStart(test1.TestMethod1));
-			try
-			{
+			try {
 				TestThread.Start();
-				while(!TestThread.IsAlive);
+				TestUtil.WaitForAlive (TestThread, "wait11");
+			}
+			catch(Exception e) {
+				Assert.Fail ("#71 Unexpected Exception" + e.Message);
+			}
+			finally {
 				TestThread.Abort();
-			}
-			catch(Exception e)
-			{
-				Fail("#71 Unexpected Exception" + e.Message);
 			}
 		}
 
@@ -370,17 +423,18 @@ namespace MonoTests.System.Threading {
 		{
 			C4Test test1 = new C4Test();
 			Thread TestThread = new Thread(new ThreadStart(test1.TestMethod1));
-			try
-			{
+			try {
 				TestThread.Start();
+			}
+			catch(Exception e) {
+				Assert.Fail ("#81 Unexpected Exception" + e.ToString());
+			}
+			finally {
 				TestThread.Abort();
-			}
-			catch(Exception e)
-			{
-				Fail("#81 Unexpected Exception" + e.ToString());
 			}
 		}
 
+		
 		public void TestJoin1()
 		{
 			C1Test test1 = new C1Test();
@@ -392,12 +446,12 @@ namespace MonoTests.System.Threading {
 				thread1.Start();
 				thread2.Start();
 				thread2.Join();
-			}
-			catch(Exception e)
+			}
+			catch(Exception e)
 			{
-				Fail("#91 Unexpected Exception " + e.ToString());
-			}
-			finally
+				Assert.Fail ("#91 Unexpected Exception " + e.ToString());
+			}
+			finally
 			{
 				thread1.Abort();
 				thread2.Abort();
@@ -409,36 +463,55 @@ namespace MonoTests.System.Threading {
 			//TODO: Test The rest of the possible transitions
 			C2Test test1 = new C2Test();
 			Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
-			AssertEquals("#101 Wrong Thread State",ThreadState.Unstarted,TestThread.ThreadState);
-			TestThread.Start();
-			//while(!TestThread.IsAlive); //In the MS Documentation this is not necessary
-										  //but in the MS SDK it is
-			Assert("#102 Wrong Thread State: " + TestThread.ThreadState.ToString(), TestThread.ThreadState == ThreadState.Running || (TestThread.ThreadState & ThreadState.Unstarted) != 0);
-			TestThread.Abort();
-			while(TestThread.IsAlive);
+			Assert.AreEqual (ThreadState.Unstarted, TestThread.ThreadState, "#101 Wrong Thread State");
+			try {
+				TestThread.Start();
+				//while(!TestThread.IsAlive); //In the MS Documentation this is not necessary
+											  //but in the MS SDK it is
+				Assert.IsTrue (TestThread.ThreadState == ThreadState.Running || (TestThread.ThreadState & ThreadState.Unstarted) != 0,
+					"#102 Wrong Thread State: " + TestThread.ThreadState.ToString ());
+			}
+			finally {
+				TestThread.Abort();
+			}
+			
+			TestUtil.WaitForNotAlive (TestThread, "wait12");
 			// Docs say state will be Stopped, but Aborted happens sometimes (?)
-			Assert("#103 Wrong Thread State: " + TestThread.ThreadState.ToString(), (ThreadState.Stopped & TestThread.ThreadState) != 0 
-				|| (ThreadState.Aborted & TestThread.ThreadState) != 0);
+			Assert.IsTrue ((ThreadState.Stopped & TestThread.ThreadState) != 0 || (ThreadState.Aborted & TestThread.ThreadState) != 0,
+				"#103 Wrong Thread State: " + TestThread.ThreadState.ToString ());
 		} 
 
 		[Test]
+		[Ignore ("see comment below.")]
 		public void CurrentPrincipal_PrincipalPolicy_NoPrincipal () 
 		{
 			// note: switching from PrincipalPolicy won't work inside the same thread
 			// because as soon as a Principal object is created the Policy doesn't matter anymore
 			Thread t = new Thread (new ThreadStart (ThreadedPrincipalTest.NoPrincipal));
-			t.Start ();
-			t.Join ();
+			try {
+				t.Start ();
+				t.Join ();
+			}
+			catch {
+				t.Abort ();
+			}
 		}
 
+#if !TARGET_JVM // AppDomain.SetPrincipalPolicy not supported for TARGET_JVM
 		[Test]
+		[Ignore ("see comment below.")]
 		public void CurrentPrincipal_PrincipalPolicy_UnauthenticatedPrincipal () 
 		{
 			// note: switching from PrincipalPolicy won't work inside the same thread
 			// because as soon as a Principal object is created the Policy doesn't matter anymore
 			Thread t = new Thread (new ThreadStart (ThreadedPrincipalTest.UnauthenticatedPrincipal));
-			t.Start ();
-			t.Join ();
+			try {
+				t.Start ();
+				t.Join ();
+			}
+			catch {
+				t.Abort ();
+			}
 		}
 
 		[Test]
@@ -447,12 +520,34 @@ namespace MonoTests.System.Threading {
 			// note: switching from PrincipalPolicy won't work inside the same thread
 			// because as soon as a Principal object is created the Policy doesn't matter anymore
 			Thread t = new Thread (new ThreadStart (ThreadedPrincipalTest.WindowsPrincipal));
-			t.Start ();
-			t.Join ();
+			try {
+				t.Start ();
+				t.Join ();
+			}
+			catch {
+				t.Abort ();
+			}
 		}
+#endif // TARGET_JVM
 		
+		[Test]
+		public void IPrincipal_CopyOnNewThread () 
+		{
+			Thread.CurrentPrincipal = new GenericPrincipal (new GenericIdentity ("bad"), null);
+			Thread t = new Thread (new ThreadStart (ThreadedPrincipalTest.CopyOnNewThread));
+			try {
+				Thread.CurrentPrincipal = new GenericPrincipal (new GenericIdentity ("good"), null);
+				t.Start ();
+				t.Join ();
+			}
+			catch {
+				t.Abort ();
+			}
+		}
+
 		int counter = 0;
 		
+		[Category("NotDotNet")]
 		public void TestSuspend ()
 		{
 			Thread t = new Thread (new ThreadStart (DoCount));
@@ -472,10 +567,12 @@ namespace MonoTests.System.Threading {
 			CheckIsRunning ("t5", t);
 			
 			t.Abort ();
-			while(t.IsAlive);
+			TestUtil.WaitForNotAlive (t, "wait13");
 			CheckIsNotRunning ("t6", t);
 		}
 		
+		[Category("NotDotNet")]
+		[Category("NotWorking")]
 		public void TestSuspendAbort ()
 		{
 			Thread t = new Thread (new ThreadStart (DoCount));
@@ -496,24 +593,24 @@ namespace MonoTests.System.Threading {
 				Thread.Sleep (10);
 				n++;
 			}
-			
-			Assert ("Timeout while waiting for abort", n < 200);
+
+			Assert.IsTrue (n < 200, "Timeout while waiting for abort");
 			
 			CheckIsNotRunning ("t6", t);
-		}		
+		}
 		
 		void CheckIsRunning (string s, Thread t)
 		{
 			int c = counter;
 			Thread.Sleep (100);
-			Assert (s, counter > c);
+			Assert.IsTrue (counter > c, s);
 		}
 		
 		void CheckIsNotRunning (string s, Thread t)
 		{
 			int c = counter;
 			Thread.Sleep (100);
-			Assert (s, counter == c);
+			Assert.AreEqual (counter, c, s);
 		}
 		
 		void WaitSuspended (string s, Thread t)
@@ -521,13 +618,13 @@ namespace MonoTests.System.Threading {
 			int n=0;
 			ThreadState state = t.ThreadState;
 			while ((state & ThreadState.Suspended) == 0) {
-				Assert (s + ": expected SuspendRequested state", (state & ThreadState.SuspendRequested) != 0);
+				Assert.IsTrue ((state & ThreadState.SuspendRequested) != 0, s + ": expected SuspendRequested state");
 				Thread.Sleep (10);
 				n++;
-				Assert (s + ": failed to suspend", n < 100);
+				Assert.IsTrue (n < 100, s + ": failed to suspend");
 				state = t.ThreadState;
 			}
-			Assert (s + ": SuspendRequested state not expected", (state & ThreadState.SuspendRequested) == 0);
+			Assert.IsTrue ((state & ThreadState.SuspendRequested) == 0, s + ": SuspendRequested state not expected");
 		}
 		
 		void WaitResumed (string s, Thread t)
@@ -536,7 +633,7 @@ namespace MonoTests.System.Threading {
 			while ((t.ThreadState & ThreadState.Suspended) != 0) {
 				Thread.Sleep (10);
 				n++;
-				Assert (s + ": failed to resume", n < 100);
+				Assert.IsTrue (n < 100, s + ": failed to resume");
 			}
 		}
 		
@@ -548,4 +645,187 @@ namespace MonoTests.System.Threading {
 			}
 		}
 	}
+
+	[TestFixture]
+	public class ThreadStateTest {
+		void Start ()
+		{
+		}
+
+		[Test] // bug #81720
+		public void IsBackGround ()
+		{
+			Thread t1 = new Thread (new ThreadStart (Start));
+			Assert.AreEqual (ThreadState.Unstarted, t1.ThreadState, "#A1");
+			Assert.IsFalse (t1.IsBackground, "#A2");
+			t1.Start ();
+			t1.Join ();
+			Assert.AreEqual (ThreadState.Stopped, t1.ThreadState, "#A3");
+
+			try {
+				bool isBackGround = t1.IsBackground;
+				Assert.Fail ("#A4: " + isBackGround.ToString ());
+			} catch (ThreadStateException ex) {
+				Assert.AreEqual (typeof (ThreadStateException), ex.GetType (), "#A5");
+				Assert.IsNull (ex.InnerException, "#A6");
+				Assert.IsNotNull (ex.Message, "#A7");
+			}
+
+			Thread t2 = new Thread (new ThreadStart (Start));
+			Assert.AreEqual (ThreadState.Unstarted, t2.ThreadState, "#B1");
+			t2.IsBackground = true;
+			Assert.AreEqual (ThreadState.Unstarted | ThreadState.Background, t2.ThreadState, "#B2");
+			Assert.IsTrue (t2.IsBackground, "#B3");
+			t2.Start ();
+			t2.Join ();
+			Assert.AreEqual (ThreadState.Stopped, t2.ThreadState, "#B4");
+
+			try {
+				bool isBackGround = t2.IsBackground;
+				Assert.Fail ("#B5: " + isBackGround.ToString ());
+			} catch (ThreadStateException ex) {
+				Assert.AreEqual (typeof (ThreadStateException), ex.GetType (), "#B6");
+				Assert.IsNull (ex.InnerException, "#B7");
+				Assert.IsNotNull (ex.Message, "#B8");
+			}
+		}
+	}
+
+	[TestFixture]
+	public class ThreadApartmentTest
+	{
+		void Start ()
+		{
+		}
+
+		[Test] // bug #81658
+		public void ApartmentState_StoppedThread ()
+		{
+			Thread t1 = new Thread (new ThreadStart (Start));
+			t1.Start ();
+			t1.Join ();
+			try {
+				ApartmentState state = t1.ApartmentState;
+				Assert.Fail ("#A1: " + state.ToString ());
+			} catch (ThreadStateException ex) {
+				Assert.AreEqual (typeof (ThreadStateException), ex.GetType (), "#A2");
+				Assert.IsNull (ex.InnerException, "#A3");
+				Assert.IsNotNull (ex.Message, "#A4");
+			}
+
+			Thread t2 = new Thread (new ThreadStart (Start));
+			t2.IsBackground = true;
+			t2.Start ();
+			t2.Join ();
+			try {
+				ApartmentState state = t2.ApartmentState;
+				Assert.Fail ("#B1: " + state.ToString ());
+			} catch (ThreadStateException ex) {
+				Assert.AreEqual (typeof (ThreadStateException), ex.GetType (), "#B2");
+				Assert.IsNull (ex.InnerException, "#B3");
+				Assert.IsNotNull (ex.Message, "#B4");
+			}
+		}
+
+		[Test]
+		public void ApartmentState_BackGround ()
+		{
+			Thread t1 = new Thread (new ThreadStart (Start));
+			t1.IsBackground = true;
+			Assert.AreEqual (ApartmentState.Unknown, t1.ApartmentState, "#1");
+			t1.ApartmentState = ApartmentState.STA;
+			Assert.AreEqual (ApartmentState.STA, t1.ApartmentState, "#2");
+		}
+
+		[Test]
+		public void TestApartmentState ()
+		{
+			Thread t1 = new Thread (new ThreadStart (Start));
+			Thread t2 = new Thread (new ThreadStart (Start));
+			Thread t3 = new Thread (new ThreadStart (Start));
+
+			Assert.AreEqual (ApartmentState.Unknown, t1.ApartmentState, "Thread1 Default");
+			Assert.AreEqual (ApartmentState.Unknown, t2.ApartmentState, "Thread2 Default");
+			Assert.AreEqual (ApartmentState.Unknown, t3.ApartmentState, "Thread3 Default");
+
+			t1.ApartmentState = ApartmentState.STA;
+			Assert.AreEqual (ApartmentState.STA, t1.ApartmentState, "Thread1 Set Once");
+			t1.ApartmentState = ApartmentState.MTA;
+			Assert.AreEqual (ApartmentState.STA, t1.ApartmentState, "Thread1 Set Twice");
+
+			t2.ApartmentState = ApartmentState.MTA;
+			Assert.AreEqual (ApartmentState.MTA, t2.ApartmentState, "Thread2 Set Once");
+			t2.ApartmentState = ApartmentState.STA;
+			Assert.AreEqual (ApartmentState.MTA, t2.ApartmentState, "Thread2 Set Twice");
+
+			bool exception_occured = false;
+			try {
+				t3.ApartmentState = ApartmentState.Unknown;
+			}
+			catch (Exception) {
+				exception_occured = true;
+			}
+			Assert.AreEqual (ApartmentState.Unknown, t3.ApartmentState, "Thread3 Set Invalid");
+#if NET_2_0
+			Assert.IsFalse (exception_occured, "Thread3 Set Invalid Exception Occured");
+#else
+			Assert.IsTrue (exception_occured, "Thread3 Set Invalid Exception Occured");
+#endif
+
+			t1.Start ();
+			exception_occured = false;
+			try {
+				t1.ApartmentState = ApartmentState.STA;
+			}
+			catch (Exception) {
+				exception_occured = true;
+			}
+			Assert.IsTrue (exception_occured, "Thread1 Started Invalid Exception Occured");
+		}
+	}
+
+	public class TestUtil
+	{
+		public static void WaitForNotAlive (Thread t, string s)
+		{
+			WhileAlive (t, true, s);
+		}
+		
+		public static void WaitForAlive (Thread t, string s)
+		{
+			WhileAlive (t, false, s);
+		}
+		
+		public static bool WaitForAliveOrStop (Thread t, string s)
+		{
+			return WhileAliveOrStop (t, false, s);
+		}
+		
+		public static void WhileAlive (Thread t, bool alive, string s)
+		{
+			DateTime ti = DateTime.Now;
+			while (t.IsAlive == alive) {
+				if ((DateTime.Now - ti).TotalSeconds > 10) {
+					if (alive) Assert.Fail ("Timeout while waiting for not alive state. " + s);
+					else Assert.Fail ("Timeout while waiting for alive state. " + s);
+				}
+			}
+		}
+
+		public static bool WhileAliveOrStop (Thread t, bool alive, string s)
+		{
+			DateTime ti = DateTime.Now;
+			while (t.IsAlive == alive) {
+				if (t.ThreadState == ThreadState.Stopped)
+					return false;
+
+				if ((DateTime.Now - ti).TotalSeconds > 10) {
+					if (alive) Assert.Fail ("Timeout while waiting for not alive state. " + s);
+					else Assert.Fail ("Timeout while waiting for alive state. " + s);
+				}
+			}
+
+			return true;
+		}
+	}
 }