1 // ThreadTest.cs - NUnit Test Cases for the System.Threading.Thread class
4 // Eduardo Garcia Cebollero (kiwnix@yahoo.es)
5 // Sebastien Pouliot <sebastien@ximian.com>
7 // (C) Eduardo Garcia Cebollero.
8 // (C) Ximian, Inc. http://www.ximian.com
9 // (C) 2004 Novell (http://www.novell.com)
13 using System.Globalization;
14 using System.Security.Principal;
15 using System.Threading;
16 using System.Reflection;
17 using System.Collections.Generic;
18 using SD = System.Diagnostics;
20 using NUnit.Framework;
22 namespace MonoTests.System.Threading
24 // These tests seem to hang the 2.0 framework. So they are disabled for now
25 // Don't reenable them until you can run a few thousand times on an SMP box.
26 [Category ("NotWorking")]
27 public class ThreadedPrincipalTest
29 public static void NoPrincipal ()
31 AppDomain.CurrentDomain.SetPrincipalPolicy (PrincipalPolicy.NoPrincipal);
32 IPrincipal p = Thread.CurrentPrincipal;
33 Assert.IsNull (p, "#1");
35 Thread.CurrentPrincipal = new GenericPrincipal (new GenericIdentity ("mono"), null);
36 Assert.IsNotNull (Thread.CurrentPrincipal, "#2");
38 Thread.CurrentPrincipal = null;
39 Assert.IsNull (Thread.CurrentPrincipal, "#3");
40 // in this case we can return to null
43 public static void UnauthenticatedPrincipal ()
45 AppDomain.CurrentDomain.SetPrincipalPolicy (PrincipalPolicy.UnauthenticatedPrincipal);
46 IPrincipal p = Thread.CurrentPrincipal;
47 Assert.IsNotNull (p, "#1");
48 Assert.IsTrue ((p is GenericPrincipal), "#2");
49 Assert.AreEqual (String.Empty, p.Identity.Name, "#3");
50 Assert.AreEqual (String.Empty, p.Identity.AuthenticationType, "#4");
51 Assert.IsFalse (p.Identity.IsAuthenticated, "#5");
53 Thread.CurrentPrincipal = new GenericPrincipal (new GenericIdentity ("mono"), null);
54 Assert.IsNotNull (Thread.CurrentPrincipal, "#6");
56 Thread.CurrentPrincipal = null;
57 Assert.IsNotNull (Thread.CurrentPrincipal, "#7");
58 // in this case we can't return to null
61 public static void WindowsPrincipal ()
63 AppDomain.CurrentDomain.SetPrincipalPolicy (PrincipalPolicy.WindowsPrincipal);
64 IPrincipal p = Thread.CurrentPrincipal;
65 Assert.IsNotNull (p, "#1");
66 Assert.IsTrue ((p is WindowsPrincipal), "#2");
67 Assert.IsNotNull (p.Identity.Name, "#3");
68 Assert.IsNotNull (p.Identity.AuthenticationType, "#4");
69 Assert.IsTrue (p.Identity.IsAuthenticated, "#5");
71 // note: we can switch from a WindowsPrincipal to a GenericPrincipal
72 Thread.CurrentPrincipal = new GenericPrincipal (new GenericIdentity ("mono"), null);
73 Assert.IsNotNull (Thread.CurrentPrincipal, "#6");
75 Thread.CurrentPrincipal = null;
76 Assert.IsNotNull (Thread.CurrentPrincipal, "#7");
77 // in this case we can't return to null
80 public static void CopyOnNewThread ()
82 Assert.IsNotNull (Thread.CurrentPrincipal, "#1");
83 Assert.AreEqual ("good", Thread.CurrentPrincipal.Identity.Name, "#2");
88 [Category("MobileNotWorking")] // Abort #10240
89 public class ThreadTest
91 //TimeSpan Infinite = new TimeSpan (-10000); // -10000 ticks == -1 ms
92 TimeSpan SmallNegative = new TimeSpan (-2); // between 0 and -1.0 (infinite) ms
93 TimeSpan Negative = new TimeSpan (-20000); // really negative
94 //TimeSpan MaxValue = TimeSpan.FromMilliseconds ((long) Int32.MaxValue);
95 TimeSpan TooLarge = TimeSpan.FromMilliseconds ((long) Int32.MaxValue + 1);
102 switch (Environment.OSVersion.Platform) {
103 case PlatformID.Win32NT:
104 case PlatformID.Win32S:
105 case PlatformID.Win32Windows:
106 case PlatformID.WinCE:
111 // check a class in mscorlib to determine if we're running on Mono
112 if (Type.GetType ("System.MonoType", false) != null)
116 //Some Classes to test as threads
120 public Thread thread1;
126 thread1 = (Thread)null;
128 endm1 = endm2 = false;
131 public void TestMethod()
139 public void TestMethod2()
141 if (!(thread1==(Thread)null) )
152 public bool run = false;
159 public void TestMethod()
174 public C1Test sub_class;
175 public Thread sub_thread;
179 sub_class = new C1Test();
180 sub_thread = new Thread(new ThreadStart(sub_class.TestMethod));
183 public void TestMethod1()
187 #if MONO_FEATURE_THREAD_ABORT
190 sub_thread.Interrupt ();
197 public C1Test class1;
198 public C1Test class2;
199 public Thread thread1;
200 public Thread thread2;
208 class1 = new C1Test();
209 class2 = new C1Test();
210 thread1 = new Thread(new ThreadStart(class1.TestMethod));
211 thread2 = new Thread(new ThreadStart(class2.TestMethod));
214 public void TestMethod1()
217 TestUtil.WaitForAlive (thread1, "wait1");
220 TestUtil.WaitForAlive (thread2, "wait2");
222 #if MONO_FEATURE_THREAD_ABORT
225 thread1.Interrupt ();
227 TestUtil.WaitForNotAlive (thread1, "wait3");
229 #if MONO_FEATURE_THREAD_ABORT
232 thread2.Interrupt ();
234 TestUtil.WaitForNotAlive (thread2, "wait4");
238 public void TestMethod2()
246 public void TestCtor1()
248 C1Test test1 = new C1Test();
249 Thread t = new Thread (new ThreadStart (test1.TestMethod));
251 Assert.IsTrue (t.CurrentCulture.IsReadOnly, "CurrentCulture.IsReadOnly");
252 Assert.IsFalse (t.IsAlive, "IsAlive");
253 Assert.IsFalse (t.IsBackground, "IsBackground");
254 Assert.IsNull (t.Name, "Name");
255 Assert.AreEqual (ThreadState.Unstarted, t.ThreadState, "ThreadState");
259 [Category ("NotWorking")] // we're not sharing (read-only) CultureInfo
260 public void CultureInfo_Shared_Across_Threads ()
262 Thread t = new Thread (TestCtor1);
263 Assert.AreSame (t.CurrentCulture, t.CurrentUICulture, "Culture");
265 Assert.AreSame (t.CurrentCulture, CultureInfo.CurrentCulture, "CultureInfo.CurrentCulture");
266 Assert.AreSame (t.CurrentUICulture, CultureInfo.CurrentUICulture, "CultureInfo.CurrentUICulture");
268 Assert.AreSame (t.CurrentCulture, Thread.CurrentThread.CurrentCulture, "Thread.CurrentThread.CurrentCulture");
269 Assert.AreSame (t.CurrentUICulture, Thread.CurrentThread.CurrentUICulture, "Thread.CurrentThread.CurrentUICulture");
272 [Test] // bug #325566
273 public void GetHashCodeTest ()
275 C1Test test1 = new C1Test ();
276 Thread tA = new Thread (new ThreadStart (test1.TestMethod));
277 int hA1 = tA.GetHashCode ();
278 Assert.IsTrue (hA1 > 0, "#A1");
280 int hA2 = tA.GetHashCode ();
281 Assert.AreEqual (hA1, hA2, "#A2");
283 int hA3 = tA.GetHashCode ();
284 Assert.AreEqual (hA1, hA3, "#A3");
285 Assert.AreEqual (hA1, tA.ManagedThreadId, "#A4");
287 test1 = new C1Test ();
288 Thread tB = new Thread (new ThreadStart (test1.TestMethod));
289 int hB1 = tB.GetHashCode ();
290 Assert.IsTrue (hB1 > 0, "#B1");
292 int hB2 = tB.GetHashCode ();
293 Assert.AreEqual (hB1, hB2, "#B2");
295 int hB3 = tB.GetHashCode ();
296 Assert.AreEqual (hB1, hB3, "#B3");
297 Assert.AreEqual (hB1, tB.ManagedThreadId, "#B4");
298 Assert.IsFalse (hA2 == hB2, "#B5");
302 public void ManagedThreadId ()
304 C1Test test1 = new C1Test ();
305 Thread t1 = new Thread (new ThreadStart (test1.TestMethod));
306 int mtA1 = t1.ManagedThreadId;
308 int mtA2 = t1.ManagedThreadId;
310 int mtA3 = t1.ManagedThreadId;
311 Assert.AreEqual (mtA1, mtA2, "#A1");
312 Assert.AreEqual (mtA2, mtA3, "#A2");
314 test1 = new C1Test ();
315 Thread t2 = new Thread (new ThreadStart (test1.TestMethod));
316 int mtB1 = t2.ManagedThreadId;
318 int mtB2 = t2.ManagedThreadId;
320 int mtB3 = t2.ManagedThreadId;
321 Assert.AreEqual (mtB1, mtB2, "#B1");
322 Assert.AreEqual (mtB2, mtB3, "#B2");
323 Assert.IsFalse (mtB1 == mtA1, "#B3");
327 [Category ("NotDotNet")] // it hangs.
328 public void TestStart()
330 if (is_win32 && is_mono)
331 Assert.Fail ("This test fails on Win32. The test should be fixed.");
333 C1Test test1 = new C1Test();
334 Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
337 Assert.AreEqual (10, test1.cnt, "#1");
340 C2Test test1 = new C2Test();
341 Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
343 #if MONO_FEATURE_THREAD_ABORT
346 TestThread.Interrupt ();
351 } catch (ThreadStateException) {
355 C2Test test1 = new C2Test();
356 Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
360 bool started = (TestThread.ThreadState == ThreadState.Running);
361 Assert.AreEqual (started, test1.run, "#15 Thread Is not in the correct state: ");
362 #if MONO_FEATURE_THREAD_ABORT
365 TestThread.Interrupt ();
371 public void TestApartmentState ()
373 if (is_win32 && is_mono)
374 Assert.Fail ("This test fails on mono on win32. Our runtime should be fixed.");
376 C2Test test1 = new C2Test();
377 Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
378 Assert.AreEqual (ApartmentState.Unknown, TestThread.ApartmentState, "#1");
380 TestUtil.WaitForAlive (TestThread, "wait5");
381 Assert.AreEqual (ApartmentState.MTA, TestThread.ApartmentState, "#2");
382 #if MONO_FEATURE_THREAD_ABORT
385 TestThread.Interrupt ();
390 [Category ("NotWorking")] // setting the priority of a Thread before it is started isn't implemented in Mono yet
391 public void TestPriority1()
393 if (is_win32 && is_mono)
394 Assert.Fail ("This test fails on mono on Win32. Our runtime should be fixed.");
396 C2Test test1 = new C2Test();
397 Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
399 TestThread.Priority=ThreadPriority.BelowNormal;
400 ThreadPriority before = TestThread.Priority;
401 Assert.AreEqual (ThreadPriority.BelowNormal, before, "#40 Unexpected priority before thread start: ");
403 TestUtil.WaitForAlive (TestThread, "wait7");
404 ThreadPriority after = TestThread.Priority;
405 Assert.AreEqual (before, after, "#41 Unexpected Priority Change: ");
407 #if MONO_FEATURE_THREAD_ABORT
410 TestThread.Interrupt ();
415 #if MONO_FEATURE_THREAD_ABORT
417 [Category ("NotDotNet")] // on MS, Thread is still in AbortRequested state when Start is invoked
418 public void AbortUnstarted ()
420 C2Test test1 = new C2Test();
421 Thread th = new Thread (new ThreadStart (test1.TestMethod));
428 [Category ("NotDotNet")] // on MS, ThreadState is immediately Stopped after Abort
429 [Category ("NotWorking")] // this is a MonoTODO -> no support for Priority
430 public void TestPriority2()
432 C2Test test1 = new C2Test();
433 Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
435 Assert.AreEqual (ThreadPriority.Normal, TestThread.Priority, "#42 Incorrect Priority in New thread: ");
437 TestUtil.WaitForAliveOrStop (TestThread, "wait8");
438 Assert.AreEqual (ThreadPriority.Normal, TestThread.Priority, "#43 Incorrect Priority in Started thread: ");
440 #if MONO_FEATURE_THREAD_ABORT
443 TestThread.Interrupt ();
446 Assert.AreEqual (ThreadPriority.Normal, TestThread.Priority, "#44 Incorrect Priority in Aborted thread: ");
450 [Category ("NotWorking")] // this is a MonoTODO -> no support for Priority
451 public void TestPriority3()
453 C2Test test1 = new C2Test();
454 Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
457 TestThread.Priority = ThreadPriority.Lowest;
458 Assert.AreEqual (ThreadPriority.Lowest, TestThread.Priority, "#45A Incorrect Priority:");
459 TestThread.Priority = ThreadPriority.BelowNormal;
460 Assert.AreEqual (ThreadPriority.BelowNormal, TestThread.Priority, "#45B Incorrect Priority:");
461 TestThread.Priority = ThreadPriority.Normal;
462 Assert.AreEqual (ThreadPriority.Normal, TestThread.Priority, "#45C Incorrect Priority:");
463 TestThread.Priority = ThreadPriority.AboveNormal;
464 Assert.AreEqual (ThreadPriority.AboveNormal, TestThread.Priority, "#45D Incorrect Priority:");
465 TestThread.Priority = ThreadPriority.Highest;
466 Assert.AreEqual (ThreadPriority.Highest, TestThread.Priority, "#45E Incorrect Priority:");
469 #if MONO_FEATURE_THREAD_ABORT
472 TestThread.Interrupt ();
478 public void TestUndivisibleByPageSizeMaxStackSize ()
480 const int undivisible_stacksize = 1048573;
482 var thread = new Thread (new ThreadStart (delegate {}), undivisible_stacksize);
488 public void TestIsBackground1 ()
490 if (is_win32 && is_mono)
491 Assert.Fail ("This test fails on mono on Win32. Our runtime should be fixed.");
493 C2Test test1 = new C2Test();
494 Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
497 TestUtil.WaitForAlive (TestThread, "wait9");
498 bool state = TestThread.IsBackground;
499 Assert.IsFalse (state, "#51 IsBackground not set at the default state: ");
501 #if MONO_FEATURE_THREAD_ABORT
504 TestThread.Interrupt ();
510 public void TestIsBackground2 ()
512 C2Test test1 = new C2Test();
513 Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
514 TestThread.IsBackground = true;
518 #if MONO_FEATURE_THREAD_ABORT
521 TestThread.Interrupt ();
525 if (TestThread.IsAlive) {
527 Assert.IsTrue (TestThread.IsBackground, "#52 Is Background Changed to Start ");
528 } catch (ThreadStateException) {
529 // Ignore if thread died meantime
535 public void TestName()
537 if (is_win32 && is_mono)
538 Assert.Fail ("This test fails on mono on Win32. Our runtime should be fixed.");
540 C2Test test1 = new C2Test();
541 Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
544 TestUtil.WaitForAlive (TestThread, "wait10");
545 string name = TestThread.Name;
546 Assert.IsNull (name, "#61 Name set when mustn't be set: ");
547 string newname = "Testing....";
548 TestThread.Name = newname;
549 Assert.AreEqual (newname, TestThread.Name, "#62 Name not set when must be set: ");
551 #if MONO_FEATURE_THREAD_ABORT
554 TestThread.Interrupt ();
562 Thread t = new Thread (new ThreadStart (Name));
563 Assert.IsNull (t.Name, "Name-1");
565 Assert.IsNull (t.Name, "Name-2");
569 [ExpectedException (typeof (InvalidOperationException))]
570 public void Rename ()
572 Thread t = new Thread (new ThreadStart (Rename));
577 bool rename_finished;
581 public void RenameTpThread ()
583 object monitor = new object ();
584 ThreadPool.QueueUserWorkItem (new WaitCallback (Rename_callback), monitor);
586 if (!rename_finished)
587 Monitor.Wait (monitor);
589 Assert.IsTrue (!rename_failed);
592 void Rename_callback (object o) {
593 Thread.CurrentThread.Name = "a";
595 Thread.CurrentThread.Name = "b";
596 //Console.WriteLine ("Thread name is: {0}", Thread.CurrentThread.Name);
597 } catch (Exception e) {
598 //Console.Error.WriteLine (e);
599 rename_failed = true;
603 rename_finished = true;
604 Monitor.Pulse (monitor);
609 public void TestNestedThreads1()
611 C3Test test1 = new C3Test();
612 Thread TestThread = new Thread(new ThreadStart(test1.TestMethod1));
615 TestUtil.WaitForAlive (TestThread, "wait11");
617 #if MONO_FEATURE_THREAD_ABORT
620 TestThread.Interrupt ();
626 public void TestNestedThreads2()
628 C4Test test1 = new C4Test();
629 Thread TestThread = new Thread(new ThreadStart(test1.TestMethod1));
633 #if MONO_FEATURE_THREAD_ABORT
636 TestThread.Interrupt ();
642 public void TestJoin1()
644 C1Test test1 = new C1Test();
645 C1Test test2 = new C1Test();
646 Thread thread1 = new Thread(new ThreadStart(test1.TestMethod));
647 Thread thread2 = new Thread(new ThreadStart(test1.TestMethod2));
653 #if MONO_FEATURE_THREAD_ABORT
657 thread1.Interrupt ();
658 thread2.Interrupt ();
664 [ExpectedException (typeof (ArgumentOutOfRangeException))]
665 public void Join_Int32_Negative ()
667 // -1 is Timeout.Infinite
668 Thread.CurrentThread.Join (-2);
672 [ExpectedException (typeof (ArgumentOutOfRangeException))]
673 public void Join_TimeSpan_Negative ()
675 Thread.CurrentThread.Join (Negative);
679 [ExpectedException (typeof (ArgumentOutOfRangeException))]
680 public void Join_TimeSpan_TooLarge ()
682 Thread.CurrentThread.Join (TooLarge);
686 public void Join_TimeSpan_SmallNegative ()
688 Thread.CurrentThread.Join (SmallNegative);
692 [ExpectedException (typeof (ArgumentOutOfRangeException))]
693 public void Sleep_Int32_Negative ()
695 // -1 is Timeout.Infinite
700 public void Sleep_TimeSpan_SmallNegative ()
702 Thread.Sleep (SmallNegative);
706 [ExpectedException (typeof (ArgumentOutOfRangeException))]
707 public void Sleep_TimeSpan_Negative ()
709 Thread.Sleep (Negative);
713 [ExpectedException (typeof (ArgumentOutOfRangeException))]
714 public void Sleep_TimeSpan_TooLarge ()
716 Thread.Sleep (TooLarge);
720 public void SpinWait ()
722 // no exception for negative numbers
723 Thread.SpinWait (Int32.MinValue);
728 public void TestThreadState ()
730 if (is_win32 && is_mono)
731 Assert.Fail ("This test fails on mono on Win32. Our runtime should be fixed.");
733 //TODO: Test The rest of the possible transitions
734 C2Test test1 = new C2Test();
735 Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
736 Assert.AreEqual (ThreadState.Unstarted, TestThread.ThreadState, "#101 Wrong Thread State");
739 //while(!TestThread.IsAlive); //In the MS Documentation this is not necessary
740 //but in the MS SDK it is
741 Assert.IsTrue (TestThread.ThreadState == ThreadState.Running || (TestThread.ThreadState & ThreadState.Unstarted) != 0,
742 "#102 Wrong Thread State: " + TestThread.ThreadState.ToString ());
744 #if MONO_FEATURE_THREAD_ABORT
747 TestThread.Interrupt ();
751 TestUtil.WaitForNotAlive (TestThread, "wait12");
752 // Docs say state will be Stopped, but Aborted happens sometimes (?)
753 Assert.IsTrue ((ThreadState.Stopped & TestThread.ThreadState) != 0 || (ThreadState.Aborted & TestThread.ThreadState) != 0,
754 "#103 Wrong Thread State: " + TestThread.ThreadState.ToString ());
758 [Ignore ("see comment below.")]
759 public void CurrentPrincipal_PrincipalPolicy_NoPrincipal ()
761 // note: switching from PrincipalPolicy won't work inside the same thread
762 // because as soon as a Principal object is created the Policy doesn't matter anymore
763 Thread t = new Thread (new ThreadStart (ThreadedPrincipalTest.NoPrincipal));
768 #if MONO_FEATURE_THREAD_ABORT
777 [Ignore ("see comment below.")]
778 public void CurrentPrincipal_PrincipalPolicy_UnauthenticatedPrincipal ()
780 // note: switching from PrincipalPolicy won't work inside the same thread
781 // because as soon as a Principal object is created the Policy doesn't matter anymore
782 Thread t = new Thread (new ThreadStart (ThreadedPrincipalTest.UnauthenticatedPrincipal));
787 #if MONO_FEATURE_THREAD_ABORT
796 public void CurrentPrincipal_PrincipalPolicy_WindowsPrincipal ()
798 // note: switching from PrincipalPolicy won't work inside the same thread
799 // because as soon as a Principal object is created the Policy doesn't matter anymore
800 Thread t = new Thread (new ThreadStart (ThreadedPrincipalTest.WindowsPrincipal));
805 #if MONO_FEATURE_THREAD_ABORT
814 public void IPrincipal_CopyOnNewThread ()
816 Thread.CurrentPrincipal = new GenericPrincipal (new GenericIdentity ("bad"), null);
817 Thread t = new Thread (new ThreadStart (ThreadedPrincipalTest.CopyOnNewThread));
819 Thread.CurrentPrincipal = new GenericPrincipal (new GenericIdentity ("good"), null);
823 #if MONO_FEATURE_THREAD_ABORT
833 #if MONO_FEATURE_THREAD_SUSPEND_RESUME
835 public void TestSuspend ()
837 Thread t = new Thread (new ThreadStart (DoCount));
838 t.IsBackground = true;
841 CheckIsRunning ("t1", t);
844 WaitSuspended ("t2", t);
846 CheckIsNotRunning ("t3", t);
849 WaitResumed ("t4", t);
851 CheckIsRunning ("t5", t);
854 TestUtil.WaitForNotAlive (t, "wait13");
855 CheckIsNotRunning ("t6", t);
859 #if MONO_FEATURE_THREAD_SUSPEND_RESUME && MONO_FEATURE_THREAD_ABORT
861 [Category("NotDotNet")] // On MS, ThreadStateException is thrown on Abort: "Thread is suspended; attempting to abort"
862 public void TestSuspendAbort ()
864 if (is_win32 && is_mono)
865 Assert.Fail ("This test fails on Win32. The test should be fixed.");
867 Thread t = new Thread (new ThreadStart (DoCount));
868 t.IsBackground = true;
871 CheckIsRunning ("t1", t);
874 WaitSuspended ("t2", t);
876 CheckIsNotRunning ("t3", t);
881 while (t.IsAlive && n < 200) {
886 Assert.IsTrue (n < 200, "Timeout while waiting for abort");
888 CheckIsNotRunning ("t6", t);
893 public void Test_Interrupt ()
895 ManualResetEvent mre = new ManualResetEvent (false);
896 bool interruptedExceptionThrown = false;
898 ThreadPool.QueueUserWorkItem (Test_Interrupt_Worker, Thread.CurrentThread);
906 } catch (ThreadInterruptedException) {
907 Assert.Fail ("ThreadInterruptedException thrown twice");
910 } catch (ThreadInterruptedException) {
911 interruptedExceptionThrown = true;
914 Assert.IsTrue (interruptedExceptionThrown, "ThreadInterruptedException expected.");
918 [ExpectedException (typeof (ArgumentNullException))]
919 public void TestQueueUserWorkItemNullCallback ()
921 ThreadPool.QueueUserWorkItem (null, null);
924 private void Test_Interrupt_Worker (object o)
926 Thread t = o as Thread;
932 [Category ("NotDotNet")] // it crashes nunit.
933 public void Test_InterruptCurrentThread ()
935 ManualResetEvent mre = new ManualResetEvent (false);
936 bool interruptedExceptionThrown = false;
938 Thread.CurrentThread.Interrupt ();
942 } catch (ThreadInterruptedException) {
947 public void GetNamedDataSlotTest ()
949 Assert.IsNotNull (Thread.GetNamedDataSlot ("te#st"), "#1");
950 Assert.AreSame (Thread.GetNamedDataSlot ("te#st"), Thread.GetNamedDataSlot ("te#st"), "#2");
953 class DomainClass : MarshalByRefObject {
958 m_thread = new Thread(ThreadProc);
959 m_thread.Start(Thread.CurrentThread);
964 public void ThreadProc (object arg) {
965 success = m_thread == Thread.CurrentThread;
969 #if MONO_FEATURE_MULTIPLE_APPDOMAINS
971 public void CurrentThread_Domains ()
973 AppDomain ad = AppDomain.CreateDomain ("foo");
974 ad.Load (typeof (DomainClass).Assembly.GetName ());
975 var o = (DomainClass)ad.CreateInstanceAndUnwrap (typeof (DomainClass).Assembly.FullName, typeof (DomainClass).FullName);
976 Assert.IsTrue (o.Run ());
977 AppDomain.Unload (ad);
979 #endif // MONO_FEATURE_MULTIPLE_APPDOMAINS
981 void CheckIsRunning (string s, Thread t)
985 Assert.IsTrue (counter > c, s);
988 void CheckIsNotRunning (string s, Thread t)
992 Assert.AreEqual (counter, c, s);
995 void WaitSuspended (string s, Thread t)
998 ThreadState state = t.ThreadState;
999 while ((state & ThreadState.Suspended) == 0) {
1000 Assert.IsTrue ((state & ThreadState.SuspendRequested) != 0, s + ": expected SuspendRequested state");
1003 Assert.IsTrue (n < 100, s + ": failed to suspend");
1004 state = t.ThreadState;
1006 Assert.IsTrue ((state & ThreadState.SuspendRequested) == 0, s + ": SuspendRequested state not expected");
1009 void WaitResumed (string s, Thread t)
1012 while ((t.ThreadState & ThreadState.Suspended) != 0) {
1015 Assert.IsTrue (n < 100, s + ": failed to resume");
1019 public void DoCount ()
1029 public class ThreadStateTest {
1034 [Test] // bug #81720
1035 public void IsBackGround ()
1037 Thread t1 = new Thread (new ThreadStart (Start));
1038 Assert.AreEqual (ThreadState.Unstarted, t1.ThreadState, "#A1");
1039 Assert.IsFalse (t1.IsBackground, "#A2");
1042 Assert.AreEqual (ThreadState.Stopped, t1.ThreadState, "#A3");
1045 bool isBackGround = t1.IsBackground;
1046 Assert.Fail ("#A4: " + isBackGround.ToString ());
1047 } catch (ThreadStateException ex) {
1048 Assert.AreEqual (typeof (ThreadStateException), ex.GetType (), "#A5");
1049 Assert.IsNull (ex.InnerException, "#A6");
1050 Assert.IsNotNull (ex.Message, "#A7");
1053 Thread t2 = new Thread (new ThreadStart (Start));
1054 Assert.AreEqual (ThreadState.Unstarted, t2.ThreadState, "#B1");
1055 t2.IsBackground = true;
1056 Assert.AreEqual (ThreadState.Unstarted | ThreadState.Background, t2.ThreadState, "#B2");
1057 Assert.IsTrue (t2.IsBackground, "#B3");
1060 Assert.AreEqual (ThreadState.Stopped, t2.ThreadState, "#B4");
1063 bool isBackGround = t2.IsBackground;
1064 Assert.Fail ("#B5: " + isBackGround.ToString ());
1065 } catch (ThreadStateException ex) {
1066 Assert.AreEqual (typeof (ThreadStateException), ex.GetType (), "#B6");
1067 Assert.IsNull (ex.InnerException, "#B7");
1068 Assert.IsNotNull (ex.Message, "#B8");
1075 public class ThreadTest_ManagedThreadId
1079 MBRO mbro = new MBRO ();
1081 class MBRO : MarshalByRefObject {
1085 public string ad_a1;
1086 public string ad_b1;
1087 public string ad_b2;
1088 public string message;
1092 public void ManagedThreadId_AppDomains ()
1094 AppDomain currentDomain = AppDomain.CurrentDomain;
1095 ad1 = AppDomain.CreateDomain ("AppDomain 1", currentDomain.Evidence, currentDomain.SetupInformation);
1096 ad2 = AppDomain.CreateDomain ("AppDomain 2", currentDomain.Evidence, currentDomain.SetupInformation);
1098 Thread a = new Thread (ThreadA);
1099 Thread b = new Thread (ThreadB);
1100 // execute on AppDomain 1 thread A
1101 // execute on AppDomain 2 thread B
1102 // execute on AppDomain 1 thread B - must have same ManagedThreadId as Ad 2 on thread B
1108 AppDomain.Unload (ad1);
1109 AppDomain.Unload (ad2);
1111 if (mbro.message != null)
1112 Assert.Fail (mbro.message);
1114 // Console.WriteLine ("Done id_a1: {0} id_b1: {1} id_b2: {2} ad_a1: {3} ad_b1: {4} ad_b2: {5}", mbro.id_a1, mbro.id_b1, mbro.id_b2, mbro.ad_a1, mbro.ad_b1, mbro.ad_b2);
1116 Assert.AreEqual ("AppDomain 1", mbro.ad_a1, "Name #1");
1117 Assert.AreEqual ("AppDomain 1", mbro.ad_b1, "Name #2");
1118 Assert.AreEqual ("AppDomain 2", mbro.ad_b2, "Name #3");
1120 Assert.AreNotEqual (mbro.id_a1, mbro.id_b1, "Id #1");
1121 Assert.AreNotEqual (mbro.id_a1, mbro.id_b2, "Id #2");
1122 Assert.AreEqual (mbro.id_b1, mbro.id_b2, "Id #3");
1124 Assert.AreNotEqual (mbro.id_a1, Thread.CurrentThread.ManagedThreadId, "Id #4");
1125 Assert.AreNotEqual (mbro.id_b1, Thread.CurrentThread.ManagedThreadId, "Id #5");
1126 Assert.AreNotEqual (mbro.id_b2, Thread.CurrentThread.ManagedThreadId, "Id #6");
1127 Assert.AreNotEqual (mbro.ad_a1, AppDomain.CurrentDomain.FriendlyName, "Name #4");
1128 Assert.AreNotEqual (mbro.ad_b1, AppDomain.CurrentDomain.FriendlyName, "Name #5");
1129 Assert.AreNotEqual (mbro.ad_b2, AppDomain.CurrentDomain.FriendlyName, "Name #6");
1134 mbro.id_a1 = Thread.CurrentThread.ManagedThreadId;
1135 mbro.ad_a1 = AppDomain.CurrentDomain.FriendlyName;
1140 mbro.id_b2 = Thread.CurrentThread.ManagedThreadId;
1141 mbro.ad_b2 = AppDomain.CurrentDomain.FriendlyName;
1146 mbro.id_b1 = Thread.CurrentThread.ManagedThreadId;
1147 mbro.ad_b1 = AppDomain.CurrentDomain.FriendlyName;
1150 void ThreadA (object obj)
1152 // Console.WriteLine ("ThreadA");
1154 ad1.DoCallBack (A1);
1155 } catch (Exception ex) {
1156 mbro.message = string.Format ("ThreadA exception: {0}", ex);
1158 // Console.WriteLine ("ThreadA Done");
1161 void ThreadB (object obj)
1163 // Console.WriteLine ("ThreadB");
1165 ad2.DoCallBack (B2);
1166 ad1.DoCallBack (B1);
1167 } catch (Exception ex) {
1168 mbro.message = string.Format ("ThreadB exception: {0}", ex);
1170 // Console.WriteLine ("ThreadB Done");
1175 public class ThreadApartmentTest
1181 [Test] // bug #81658
1182 public void ApartmentState_StoppedThread ()
1184 Thread t1 = new Thread (new ThreadStart (Start));
1188 ApartmentState state = t1.ApartmentState;
1189 Assert.Fail ("#A1: " + state.ToString ());
1190 } catch (ThreadStateException ex) {
1191 Assert.AreEqual (typeof (ThreadStateException), ex.GetType (), "#A2");
1192 Assert.IsNull (ex.InnerException, "#A3");
1193 Assert.IsNotNull (ex.Message, "#A4");
1196 Thread t2 = new Thread (new ThreadStart (Start));
1197 t2.IsBackground = true;
1201 ApartmentState state = t2.ApartmentState;
1202 Assert.Fail ("#B1: " + state.ToString ());
1203 } catch (ThreadStateException ex) {
1204 Assert.AreEqual (typeof (ThreadStateException), ex.GetType (), "#B2");
1205 Assert.IsNull (ex.InnerException, "#B3");
1206 Assert.IsNotNull (ex.Message, "#B4");
1211 public void ApartmentState_BackGround ()
1213 Thread t1 = new Thread (new ThreadStart (Start));
1214 t1.IsBackground = true;
1215 Assert.AreEqual (ApartmentState.Unknown, t1.ApartmentState, "#1");
1216 t1.ApartmentState = ApartmentState.STA;
1217 Assert.AreEqual (ApartmentState.STA, t1.ApartmentState, "#2");
1221 public void TestApartmentState ()
1223 Thread t1 = new Thread (new ThreadStart (Start));
1224 Thread t2 = new Thread (new ThreadStart (Start));
1225 Thread t3 = new Thread (new ThreadStart (Start));
1227 Assert.AreEqual (ApartmentState.Unknown, t1.ApartmentState, "Thread1 Default");
1228 Assert.AreEqual (ApartmentState.Unknown, t2.ApartmentState, "Thread2 Default");
1229 Assert.AreEqual (ApartmentState.Unknown, t3.ApartmentState, "Thread3 Default");
1231 t1.ApartmentState = ApartmentState.STA;
1232 Assert.AreEqual (ApartmentState.STA, t1.ApartmentState, "Thread1 Set Once");
1233 t1.ApartmentState = ApartmentState.MTA;
1234 Assert.AreEqual (ApartmentState.STA, t1.ApartmentState, "Thread1 Set Twice");
1236 t2.ApartmentState = ApartmentState.MTA;
1237 Assert.AreEqual (ApartmentState.MTA, t2.ApartmentState, "Thread2 Set Once");
1238 t2.ApartmentState = ApartmentState.STA;
1239 Assert.AreEqual (ApartmentState.MTA, t2.ApartmentState, "Thread2 Set Twice");
1241 bool exception_occured = false;
1243 t3.ApartmentState = ApartmentState.Unknown;
1246 exception_occured = true;
1248 Assert.AreEqual (ApartmentState.Unknown, t3.ApartmentState, "Thread3 Set Invalid");
1249 Assert.IsFalse (exception_occured, "Thread3 Set Invalid Exception Occured");
1252 exception_occured = false;
1254 t1.ApartmentState = ApartmentState.STA;
1257 exception_occured = true;
1259 Assert.IsTrue (exception_occured, "Thread1 Started Invalid Exception Occured");
1263 public void TestSetApartmentStateSameState ()
1265 Thread t1 = new Thread (new ThreadStart (Start));
1266 t1.SetApartmentState (ApartmentState.STA);
1267 Assert.AreEqual (ApartmentState.STA, t1.ApartmentState, "Thread1 Set Once");
1269 t1.SetApartmentState (ApartmentState.STA);
1270 Assert.AreEqual (ApartmentState.STA, t1.ApartmentState, "Thread1 Set twice");
1274 [ExpectedException(typeof(InvalidOperationException))]
1275 public void TestSetApartmentStateDiffState ()
1277 Thread t1 = new Thread (new ThreadStart (Start));
1278 t1.SetApartmentState (ApartmentState.STA);
1279 Assert.AreEqual (ApartmentState.STA, t1.ApartmentState, "Thread1 Set Once");
1281 t1.SetApartmentState (ApartmentState.MTA);
1285 public void TestTrySetApartmentState ()
1287 Thread t1 = new Thread (new ThreadStart (Start));
1288 t1.SetApartmentState (ApartmentState.STA);
1289 Assert.AreEqual (ApartmentState.STA, t1.ApartmentState, "#1");
1291 bool result = t1.TrySetApartmentState (ApartmentState.MTA);
1292 Assert.IsFalse (result, "#2");
1294 result = t1.TrySetApartmentState (ApartmentState.STA);
1295 Assert.IsTrue (result, "#3");
1299 public void TestTrySetApartmentStateRunning ()
1301 Thread t1 = new Thread (new ThreadStart (Start));
1302 t1.SetApartmentState (ApartmentState.STA);
1303 Assert.AreEqual (ApartmentState.STA, t1.ApartmentState, "#1");
1308 t1.TrySetApartmentState (ApartmentState.STA);
1310 } catch (ThreadStateException) {
1317 public void Volatile () {
1319 Thread.VolatileWrite (ref v3, double.MaxValue);
1320 Assert.AreEqual (v3, double.MaxValue);
1323 Thread.VolatileWrite (ref v4, float.MaxValue);
1324 Assert.AreEqual (v4, float.MaxValue);
1328 public void Culture ()
1330 Assert.IsNotNull (Thread.CurrentThread.CurrentCulture, "CurrentCulture");
1331 Assert.IsNotNull (Thread.CurrentThread.CurrentUICulture, "CurrentUICulture");
1335 public void ThreadStartSimple ()
1338 Thread t = new Thread (delegate () {
1339 // ensure the NSAutoreleasePool works
1344 Assert.AreEqual (1, i, "ThreadStart");
1348 public void ParametrizedThreadStart ()
1352 Thread t = new Thread (delegate (object obj) {
1353 // ensure the NSAutoreleasePool works
1360 Assert.AreEqual (1, i, "ParametrizedThreadStart");
1361 Assert.AreEqual (this, arg, "obj");
1365 public void SetNameTpThread () {
1366 ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProc));
1369 static void ThreadProc(Object stateInfo) {
1370 Thread.CurrentThread.Name = "My Worker";
1374 public void GetStackTraces () {
1375 var m = typeof (Thread).GetMethod ("Mono_GetStackTraces", BindingFlags.NonPublic|BindingFlags.Static);
1377 var res = (Dictionary<Thread,SD.StackTrace>)typeof (Thread).GetMethod ("Mono_GetStackTraces", BindingFlags.NonPublic|BindingFlags.Static).Invoke (null, null);
1378 foreach (var t in res.Keys) {
1379 var st = res [t].ToString ();
1385 public class TestUtil
1387 public static void WaitForNotAlive (Thread t, string s)
1389 WhileAlive (t, true, s);
1392 public static void WaitForAlive (Thread t, string s)
1394 WhileAlive (t, false, s);
1397 public static bool WaitForAliveOrStop (Thread t, string s)
1399 return WhileAliveOrStop (t, false, s);
1402 public static void WhileAlive (Thread t, bool alive, string s)
1404 DateTime ti = DateTime.Now;
1405 while (t.IsAlive == alive) {
1406 if ((DateTime.Now - ti).TotalSeconds > 10) {
1407 if (alive) Assert.Fail ("Timeout while waiting for not alive state. " + s);
1408 else Assert.Fail ("Timeout while waiting for alive state. " + s);
1413 public static bool WhileAliveOrStop (Thread t, bool alive, string s)
1415 DateTime ti = DateTime.Now;
1416 while (t.IsAlive == alive) {
1417 if (t.ThreadState == ThreadState.Stopped)
1420 if ((DateTime.Now - ti).TotalSeconds > 10) {
1421 if (alive) Assert.Fail ("Timeout while waiting for not alive state. " + s);
1422 else Assert.Fail ("Timeout while waiting for alive state. " + s);