mcs/class/corlib/Test/System.Threading/ThreadTest.cs

   1 // ThreadTest.cs - NUnit Test Cases for the System.Threading.Thread class
   2 //
   3 // Authors
   4 //      Eduardo Garcia Cebollero (kiwnix@yahoo.es)
   5 //      Sebastien Pouliot  <sebastien@ximian.com>
   6 //
   7 // (C) Eduardo Garcia Cebollero.
   8 // (C) Ximian, Inc.  http://www.ximian.com
   9 // (C) 2004 Novell (http://www.novell.com)
  10 //
  11
  12 using NUnit.Framework;
  13 using System;
  14 using System.Security.Principal;
  15 using System.Threading;
  16
  17 namespace MonoTests.System.Threading {
  18
  19         public class ThreadedPrincipalTest : Assertion {
  20
  21                 public static void NoPrincipal ()
  22                 {
  23                         AppDomain.CurrentDomain.SetPrincipalPolicy (PrincipalPolicy.NoPrincipal);
  24                         IPrincipal p = Thread.CurrentPrincipal;
  25                         AssertNull ("Thread.CurrentPrincipal-1", p);
  26
  27                         Thread.CurrentPrincipal = new GenericPrincipal (new GenericIdentity ("mono"), null);
  28                         AssertNotNull ("Thread.CurrentPrincipal-2", Thread.CurrentPrincipal);
  29
  30                         Thread.CurrentPrincipal = null;
  31                         AssertNull ("Thread.CurrentPrincipal-3", Thread.CurrentPrincipal);
  32                         // in this case we can return to null
  33                 }
  34
  35                 public static void UnauthenticatedPrincipal ()
  36                 {
  37                         AppDomain.CurrentDomain.SetPrincipalPolicy (PrincipalPolicy.UnauthenticatedPrincipal);
  38                         IPrincipal p = Thread.CurrentPrincipal;
  39                         AssertNotNull ("Thread.CurrentPrincipal", p);
  40                         Assert ("Type", (p is GenericPrincipal));
  41                         AssertEquals ("Name", String.Empty, p.Identity.Name);
  42                         AssertEquals ("AuthenticationType", String.Empty, p.Identity.AuthenticationType);
  43                         Assert ("IsAuthenticated", !p.Identity.IsAuthenticated);
  44
  45                         Thread.CurrentPrincipal = new GenericPrincipal (new GenericIdentity ("mono"), null);
  46                         AssertNotNull ("Thread.CurrentPrincipal-2", Thread.CurrentPrincipal);
  47
  48                         Thread.CurrentPrincipal = null;
  49                         AssertNotNull ("Thread.CurrentPrincipal-3", Thread.CurrentPrincipal);
  50                         // in this case we can't return to null
  51                 }
  52
  53                 public static void WindowsPrincipal ()
  54                 {
  55                         AppDomain.CurrentDomain.SetPrincipalPolicy (PrincipalPolicy.WindowsPrincipal);
  56                         IPrincipal p = Thread.CurrentPrincipal;
  57                         AssertNotNull ("Thread.CurrentPrincipal", p);
  58                         Assert ("Type", (p is WindowsPrincipal));
  59                         AssertNotNull ("Name", p.Identity.Name);
  60                         AssertNotNull ("AuthenticationType", p.Identity.AuthenticationType);
  61                         Assert ("IsAuthenticated", p.Identity.IsAuthenticated);
  62
  63                         // note: we can switch from a WindowsPrincipal to a GenericPrincipal
  64                         Thread.CurrentPrincipal = new GenericPrincipal (new GenericIdentity ("mono"), null);
  65                         AssertNotNull ("Thread.CurrentPrincipal-2", Thread.CurrentPrincipal);
  66
  67                         Thread.CurrentPrincipal = null;
  68                         AssertNotNull ("Thread.CurrentPrincipal-3", Thread.CurrentPrincipal);
  69                         // in this case we can't return to null
  70                 }
  71         }
  72
  73         [TestFixture]
  74         public class ThreadTest : Assertion {
  75
  76                 //Some Classes to test as threads
  77                 private class C1Test
  78                 {
  79                         public int cnt;
  80                         public Thread thread1;
  81                         public bool endm1;
  82                         public bool endm2;
  83
  84                         public C1Test()
  85                         {
  86                                 thread1 = (Thread)null;
  87                                 this.cnt = 0;
  88                                 endm1 = endm2 = false;
  89                         }
  90
  91                         public void TestMethod()
  92                         {
  93                                 while (cnt < 10)
  94                                 {
  95                                         cnt++;
  96                                 }
  97                                 endm1 = true;
  98                         }
  99                         public void TestMethod2()
 100                         {
 101                                 if (!(thread1==(Thread)null) )
 102                                 {
 103                                         thread1.Join();
 104                                 }
 105                                 endm2 = true;
 106                         }
 107                 }
 108
 109                 private class C2Test
 110                 {
 111                         public int cnt;
 112                         public bool run = false;
 113
 114                         public C2Test()
 115                         {
 116                                 this.cnt = 0;
 117                         }
 118
 119                         public void TestMethod()
 120                         {
 121                                 run = true;
 122                                 while (true)
 123                                 {
 124                                         if (cnt < 1000)
 125                                                 cnt++;
 126                                         else
 127                                                 cnt = 0;
 128                                 }
 129                         }
 130                 }
 131
 132                 private class C3Test
 133                 {
 134                         public C1Test sub_class;
 135                         public Thread sub_thread;
 136
 137                         public C3Test()
 138                         {
 139                                 sub_class = new C1Test();
 140                                 sub_thread = new Thread(new ThreadStart(sub_class.TestMethod));
 141                         }
 142
 143                         public void TestMethod1()
 144                         {
 145                                 sub_thread.Start();
 146                                 Thread.Sleep (100);
 147                                 sub_thread.Abort();
 148                         }
 149                 }
 150
 151                 private class C4Test
 152                 {
 153                         public C1Test class1;
 154                         public C1Test class2;
 155                         public Thread thread1;
 156                         public Thread thread2;
 157                         public bool T1ON ;
 158                         public bool T2ON ;
 159
 160                         public C4Test()
 161                         {
 162                                 T1ON = false;
 163                                 T2ON = false;
 164                                 class1 = new C1Test();
 165                                 class2 = new C1Test();
 166                                 thread1 = new Thread(new ThreadStart(class1.TestMethod));
 167                                 thread2 = new Thread(new ThreadStart(class2.TestMethod));
 168                         }
 169
 170                         public void TestMethod1()
 171                         {
 172                                 thread1.Start();
 173                                 TestUtil.WaitForAlive (thread1, "wait1");
 174                                 T1ON = true;
 175                                 thread2.Start();
 176                                 TestUtil.WaitForAlive (thread2, "wait2");
 177                                 T2ON = true;
 178                                 thread1.Abort();
 179                                 TestUtil.WaitForNotAlive (thread1, "wait3");
 180                                 T1ON = false;
 181                                 thread2.Abort();
 182                                 TestUtil.WaitForNotAlive (thread2, "wait4");
 183                                 T2ON = false;
 184                         }
 185
 186                         public void TestMethod2()
 187                         {
 188                                 thread1.Start();
 189                                 thread1.Join();
 190                         }
 191                 }
 192
 193                 public void TestCtor1()
 194                 {
 195                         C1Test test1 = new C1Test();
 196                         try
 197                         {
 198                                 Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
 199                         }
 200                         catch (Exception e)
 201                         {
 202                                 Fail ("#01 Unexpected Exception Thrown: " + e.ToString ());
 203                         }
 204                 }
 205
 206                 [Category("NotDotNet")]
 207                 public void TestStart()
 208                 {
 209                 {
 210                         C1Test test1 = new C1Test();
 211                         Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
 212                         try
 213                         {
 214                                 TestThread.Start();
 215                         }
 216                         catch (Exception e)
 217                         {
 218                                 Fail ("#12 Unexpected Exception Thrown: " + e.ToString ());
 219                         }
 220                         TestThread.Join();
 221                         AssertEquals("#13 Thread Not started: ", 10,test1.cnt);
 222                 }
 223                 {
 224                         bool errorThrown = false;
 225                         C2Test test1 = new C2Test();
 226                         Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
 227                         TestThread.Start();
 228                         TestThread.Abort();
 229                         try
 230                         {
 231                                 TestThread.Start();
 232                         }
 233                         catch(ThreadStateException)
 234                         {
 235                                 errorThrown = true;
 236                         }
 237                         Assert ("#14 no ThreadStateException trown", errorThrown);
 238                 }
 239                 {
 240                         C2Test test1 = new C2Test();
 241                         Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
 242                         TestThread.Start();
 243                         while(!test1.run);
 244                         bool started = (TestThread.ThreadState == ThreadState.Running);
 245                         AssertEquals("#15 Thread Is not in the correct state: ", started , test1.run);
 246                         TestThread.Abort();
 247                 }
 248                 }
 249
 250                 public void TestApartment()
 251                 {
 252                         C2Test test1 = new C2Test();
 253                         Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
 254                         ApartmentState before = TestThread.ApartmentState;
 255                         TestThread.Start();
 256                         TestUtil.WaitForAlive (TestThread, "wait5");
 257                         ApartmentState after = TestThread.ApartmentState;
 258                         TestThread.Abort();
 259                         AssertEquals("#21 Apartment State Changed when not needed",before,after);
 260                 }
 261
 262                 public void TestApartmentState()
 263                 {
 264                         C2Test test1 = new C2Test();
 265                         Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
 266                         ApartmentState before = TestThread.ApartmentState;
 267                         TestThread.Start();
 268                         TestUtil.WaitForAlive (TestThread, "wait6");
 269                         ApartmentState after = TestThread.ApartmentState;
 270                         TestThread.Abort();
 271                         AssertEquals("#31 Apartment State Changed when not needed: ",before,after);
 272                 }
 273
 274                 public void TestPriority1()
 275                 {
 276                         C2Test test1 = new C2Test();
 277                         Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
 278                         try {
 279                                 TestThread.Priority=ThreadPriority.BelowNormal;
 280                                 ThreadPriority after = TestThread.Priority;
 281                                 TestThread.Start();
 282                                 TestUtil.WaitForAlive (TestThread, "wait7");
 283                                 ThreadPriority before = TestThread.Priority;
 284                                 AssertEquals("#41 Unexpected Priority Change: ",before,after);
 285                         }
 286                         finally {
 287                                 TestThread.Abort();
 288                         }
 289                 }
 290
 291                 public void TestPriority2()
 292                 {
 293                         C2Test test1 = new C2Test();
 294                         Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
 295                         try {
 296                                 AssertEquals("#42 Incorrect Priority in New thread: ",ThreadPriority.Normal, TestThread.Priority);
 297                                 TestThread.Start();
 298                                 TestUtil.WaitForAlive (TestThread, "wait8");
 299                                 AssertEquals("#43 Incorrect Priority in Started thread: ",ThreadPriority.Normal, TestThread.Priority);
 300                         }
 301                         finally {
 302                                 TestThread.Abort();
 303                         }
 304                         AssertEquals("#44 Incorrect Priority in Aborted thread: ",ThreadPriority.Normal, TestThread.Priority);
 305                 }
 306
 307                 public void TestPriority3()
 308                 {
 309                         C2Test test1 = new C2Test();
 310                         Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
 311                         try {
 312                                 TestThread.Start();
 313                                 TestThread.Priority = ThreadPriority.Lowest;
 314                                 AssertEquals("#45A Incorrect Priority:",ThreadPriority.Lowest,TestThread.Priority);
 315                                 TestThread.Priority = ThreadPriority.BelowNormal;
 316                                 AssertEquals("#45B Incorrect Priority:",ThreadPriority.BelowNormal,TestThread.Priority);
 317                                 TestThread.Priority = ThreadPriority.Normal;
 318                                 AssertEquals("#45C Incorrect Priority:",ThreadPriority.Normal,TestThread.Priority);
 319                                 TestThread.Priority = ThreadPriority.AboveNormal;
 320                                 AssertEquals("#45D Incorrect Priority:",ThreadPriority.AboveNormal,TestThread.Priority);
 321                                 TestThread.Priority = ThreadPriority.Highest;
 322                                 AssertEquals("#45E Incorrect Priority:",ThreadPriority.Highest,TestThread.Priority);
 323                         }
 324                         finally {
 325                                 TestThread.Abort();
 326                         }
 327                 }
 328
 329
 330                 public void TestIsBackground1()
 331                 {
 332                         C2Test test1 = new C2Test();
 333                         Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
 334                         try {
 335                                 TestThread.Start();
 336                                 TestUtil.WaitForAlive (TestThread, "wait9");
 337                                 bool state = TestThread.IsBackground;
 338                                 Assert("#51 IsBackground not set at the default state: ",!(state));
 339                         }
 340                         finally {
 341                                 TestThread.Abort();
 342                         }
 343                 }
 344
 345                 public void TestIsBackground2()
 346                 {
 347                         C2Test test1 = new C2Test();
 348                         Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
 349                         TestThread.IsBackground = true;
 350                         try {
 351                                 TestThread.Start();
 352                         }
 353                         finally {
 354                                 TestThread.Abort();
 355                         }
 356                         Assert("#52 Is Background Changed ot Start ",TestThread.IsBackground);
 357                 }
 358
 359
 360                 public void TestName()
 361                 {
 362                         C2Test test1 = new C2Test();
 363                         Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
 364                         try {
 365                                 TestThread.Start();
 366                                 TestUtil.WaitForAlive (TestThread, "wait10");
 367                                 string name = TestThread.Name;
 368                                 AssertEquals("#61 Name set when mustn't be set: ", name, (string)null);
 369                                 string newname = "Testing....";
 370                                 TestThread.Name = newname;
 371                                 AssertEquals("#62 Name not set when must be set: ",TestThread.Name,newname);
 372                         }
 373                         finally {
 374                                 TestThread.Abort();
 375                         }
 376                 }
 377
 378                 [Category("NotDotNet")]
 379                 public void TestNestedThreads1()
 380                 {
 381                         C3Test  test1 = new C3Test();
 382                         Thread TestThread = new Thread(new ThreadStart(test1.TestMethod1));
 383                         try {
 384                                 TestThread.Start();
 385                                 TestUtil.WaitForAlive (TestThread, "wait11");
 386                         }
 387                         catch(Exception e) {
 388                                 Fail("#71 Unexpected Exception" + e.Message);
 389                         }
 390                         finally {
 391                                 TestThread.Abort();
 392                         }
 393                 }
 394
 395                 public void TestNestedThreads2()
 396                 {
 397                         C4Test test1 = new C4Test();
 398                         Thread TestThread = new Thread(new ThreadStart(test1.TestMethod1));
 399                         try {
 400                                 TestThread.Start();
 401                         }
 402                         catch(Exception e) {
 403                                 Fail("#81 Unexpected Exception" + e.ToString());
 404                         }
 405                         finally {
 406                                 TestThread.Abort();
 407                         }
 408                 }
 409
 410                 public void TestJoin1()
 411                 {
 412                         C1Test test1 = new C1Test();
 413                         C1Test test2 = new C1Test();
 414                         Thread thread1 = new Thread(new ThreadStart(test1.TestMethod));
 415                         Thread thread2 = new Thread(new ThreadStart(test1.TestMethod2));
 416                         try
 417                         {
 418                                 thread1.Start();
 419                                 thread2.Start();
 420                                 thread2.Join();
 421                         }
 422                         catch(Exception e)
 423                         {
 424                                 Fail("#91 Unexpected Exception " + e.ToString());
 425                         }
 426                         finally
 427                         {
 428                                 thread1.Abort();
 429                                 thread2.Abort();
 430                         }
 431                 }
 432
 433                 public void TestThreadState()
 434                 {
 435                         //TODO: Test The rest of the possible transitions
 436                         C2Test test1 = new C2Test();
 437                         Thread TestThread = new Thread(new ThreadStart(test1.TestMethod));
 438                         AssertEquals("#101 Wrong Thread State",ThreadState.Unstarted,TestThread.ThreadState);
 439                         try {
 440                                 TestThread.Start();
 441                                 //while(!TestThread.IsAlive); //In the MS Documentation this is not necessary
 442                                                                                           //but in the MS SDK it is
 443                                 Assert("#102 Wrong Thread State: " + TestThread.ThreadState.ToString(), TestThread.ThreadState == ThreadState.Running || (TestThread.ThreadState & ThreadState.Unstarted) != 0);
 444                         }
 445                         finally {
 446                                 TestThread.Abort();
 447                         }
 448
 449                         TestUtil.WaitForNotAlive (TestThread, "wait12");
 450                         // Docs say state will be Stopped, but Aborted happens sometimes (?)
 451                         Assert("#103 Wrong Thread State: " + TestThread.ThreadState.ToString(), (ThreadState.Stopped & TestThread.ThreadState) != 0
 452                                 || (ThreadState.Aborted & TestThread.ThreadState) != 0);
 453                 }
 454
 455                 [Test]
 456                 public void CurrentPrincipal_PrincipalPolicy_NoPrincipal ()
 457                 {
 458                         // note: switching from PrincipalPolicy won't work inside the same thread
 459                         // because as soon as a Principal object is created the Policy doesn't matter anymore
 460                         Thread t = new Thread (new ThreadStart (ThreadedPrincipalTest.NoPrincipal));
 461                         try {
 462                                 t.Start ();
 463                                 t.Join ();
 464                         }
 465                         catch {
 466                                 t.Abort ();
 467                         }
 468                 }
 469
 470                 [Test]
 471                 public void CurrentPrincipal_PrincipalPolicy_UnauthenticatedPrincipal ()
 472                 {
 473                         // note: switching from PrincipalPolicy won't work inside the same thread
 474                         // because as soon as a Principal object is created the Policy doesn't matter anymore
 475                         Thread t = new Thread (new ThreadStart (ThreadedPrincipalTest.UnauthenticatedPrincipal));
 476                         try {
 477                                 t.Start ();
 478                                 t.Join ();
 479                         }
 480                         catch {
 481                                 t.Abort ();
 482                         }
 483                 }
 484
 485                 [Test]
 486                 public void CurrentPrincipal_PrincipalPolicy_WindowsPrincipal ()
 487                 {
 488                         // note: switching from PrincipalPolicy won't work inside the same thread
 489                         // because as soon as a Principal object is created the Policy doesn't matter anymore
 490                         Thread t = new Thread (new ThreadStart (ThreadedPrincipalTest.WindowsPrincipal));
 491                         try {
 492                                 t.Start ();
 493                                 t.Join ();
 494                         }
 495                         catch {
 496                                 t.Abort ();
 497                         }
 498                 }
 499
 500                 int counter = 0;
 501
 502                 public void TestSuspend ()
 503                 {
 504                         Thread t = new Thread (new ThreadStart (DoCount));
 505                         t.IsBackground = true;
 506                         t.Start ();
 507
 508                         CheckIsRunning ("t1", t);
 509
 510                         t.Suspend ();
 511                         WaitSuspended ("t2", t);
 512
 513                         CheckIsNotRunning ("t3", t);
 514
 515                         t.Resume ();
 516                         WaitResumed ("t4", t);
 517
 518                         CheckIsRunning ("t5", t);
 519
 520                         t.Abort ();
 521                         TestUtil.WaitForNotAlive (t, "wait13");
 522                         CheckIsNotRunning ("t6", t);
 523                 }
 524
 525                 public void TestSuspendAbort ()
 526                 {
 527                         Thread t = new Thread (new ThreadStart (DoCount));
 528                         t.IsBackground = true;
 529                         t.Start ();
 530
 531                         CheckIsRunning ("t1", t);
 532
 533                         t.Suspend ();
 534                         WaitSuspended ("t2", t);
 535
 536                         CheckIsNotRunning ("t3", t);
 537
 538                         t.Abort ();
 539
 540                         int n=0;
 541                         while (t.IsAlive && n < 200) {
 542                                 Thread.Sleep (10);
 543                                 n++;
 544                         }
 545
 546                         Assert ("Timeout while waiting for abort", n < 200);
 547
 548                         CheckIsNotRunning ("t6", t);
 549                 }
 550
 551                 void CheckIsRunning (string s, Thread t)
 552                 {
 553                         int c = counter;
 554                         Thread.Sleep (100);
 555                         Assert (s, counter > c);
 556                 }
 557
 558                 void CheckIsNotRunning (string s, Thread t)
 559                 {
 560                         int c = counter;
 561                         Thread.Sleep (100);
 562                         Assert (s, counter == c);
 563                 }
 564
 565                 void WaitSuspended (string s, Thread t)
 566                 {
 567                         int n=0;
 568                         ThreadState state = t.ThreadState;
 569                         while ((state & ThreadState.Suspended) == 0) {
 570                                 Assert (s + ": expected SuspendRequested state", (state & ThreadState.SuspendRequested) != 0);
 571                                 Thread.Sleep (10);
 572                                 n++;
 573                                 Assert (s + ": failed to suspend", n < 100);
 574                                 state = t.ThreadState;
 575                         }
 576                         Assert (s + ": SuspendRequested state not expected", (state & ThreadState.SuspendRequested) == 0);
 577                 }
 578
 579                 void WaitResumed (string s, Thread t)
 580                 {
 581                         int n=0;
 582                         while ((t.ThreadState & ThreadState.Suspended) != 0) {
 583                                 Thread.Sleep (10);
 584                                 n++;
 585                                 Assert (s + ": failed to resume", n < 100);
 586                         }
 587                 }
 588
 589                 public void DoCount ()
 590                 {
 591                         while (true) {
 592                                 counter++;
 593                                 Thread.Sleep (1);
 594                         }
 595                 }
 596         }
 597
 598         public class TestUtil
 599         {
 600                 public static void WaitForNotAlive (Thread t, string s)
 601                 {
 602                         WhileAlive (t, true, s);
 603                 }
 604
 605                 public static void WaitForAlive (Thread t, string s)
 606                 {
 607                         WhileAlive (t, false, s);
 608                 }
 609
 610                 public static void WhileAlive (Thread t, bool alive, string s)
 611                 {
 612                         DateTime ti = DateTime.Now;
 613                         while (t.IsAlive == alive) {
 614                                 if ((DateTime.Now - ti).TotalSeconds > 10) {
 615                                         if (alive) Assertion.Fail ("Timeout while waiting for not alive state. " + s);
 616                                         else Assertion.Fail ("Timeout while waiting for alive state. " + s);
 617                                 }
 618                         }
 619                 }
 620         }
 621 }