mcs/nunit24/NUnitCore/core/TestRunnerThread.cs

   1 // ****************************************************************
   2 // This is free software licensed under the NUnit license. You
   3 // may obtain a copy of the license as well as information regarding
   4 // copyright ownership at http://nunit.org/?p=license&r=2.4.
   5 // ****************************************************************
   6
   7 using System;
   8 using System.Threading;
   9 using System.Configuration;
  10 using System.Collections.Specialized;
  11
  12 namespace NUnit.Core
  13 {
  14         /// <summary>
  15         /// TestRunnerThread encapsulates running a test on a thread.
  16         /// It knows how to create the thread based on configuration
  17         /// settings and can cancel abort the test if necessary.
  18         /// </summary>
  19         public class TestRunnerThread
  20         {
  21                 #region Private Fields
  22
  23                 /// <summary>
  24                 /// The Test runner to be used in running tests on the thread
  25                 /// </summary>
  26                 private TestRunner runner;
  27
  28                 /// <summary>
  29                 /// The System.Threading.Thread created by the object
  30                 /// </summary>
  31                 private Thread thread;
  32
  33                 /// <summary>
  34                 /// Collection of TestRunner settings from the config file
  35                 /// </summary>
  36                 private NameValueCollection settings;
  37
  38                 /// <summary>
  39                 /// The EventListener interface to receive test events
  40                 /// </summary>
  41                 private NUnit.Core.EventListener listener;
  42
  43                 /// <summary>
  44                 /// Array of test names for ues by the thread proc
  45                 /// </summary>
  46                 //private string[] testNames;
  47                 private ITestFilter filter;
  48
  49                 /// <summary>
  50                 /// Array of returned results
  51                 /// </summary>
  52                 private TestResult[] results;
  53
  54                 #endregion
  55
  56                 #region Properties
  57
  58                 /// <summary>
  59                 /// True if the thread is executing
  60                 /// </summary>
  61                 public bool IsAlive
  62                 {
  63                         get     { return this.thread.IsAlive; }
  64                 }
  65
  66                 /// <summary>
  67                 /// Array of returned results
  68                 /// </summary>
  69                 public TestResult[] Results
  70                 {
  71                         get { return results; }
  72                 }
  73
  74                 #endregion
  75
  76                 #region Constructor
  77
  78                 public TestRunnerThread( TestRunner runner )
  79                 {
  80                         this.runner = runner;
  81                         this.thread = new Thread( new ThreadStart( TestRunnerThreadProc ) );
  82                         thread.IsBackground = true;
  83                         thread.Name = "TestRunnerThread";
  84
  85                         this.settings = (NameValueCollection)
  86                                 ConfigurationSettings.GetConfig( "NUnit/TestRunner" );
  87
  88                         if ( settings != null )
  89                         {
  90                                 try
  91                                 {
  92                                         string apartment = settings["ApartmentState"];
  93                                         if ( apartment != null )
  94                                                 thread.ApartmentState = (ApartmentState)
  95                                                         System.Enum.Parse( typeof( ApartmentState ), apartment, true );
  96
  97                                         string priority = settings["ThreadPriority"];
  98                                         if ( priority != null )
  99                                                 thread.Priority = (ThreadPriority)
 100                                                         System.Enum.Parse( typeof( ThreadPriority ), priority, true );
 101                                 }
 102                                 catch( ArgumentException ex )
 103                                 {
 104                                         string msg = string.Format( "Invalid configuration setting in {0}",
 105                                                 AppDomain.CurrentDomain.SetupInformation.ConfigurationFile );
 106                                         throw new ArgumentException( msg, ex );
 107                                 }
 108                         }
 109                 }
 110
 111                 #endregion
 112
 113                 #region Public Methods
 114
 115                 public void Wait()
 116                 {
 117                         if ( this.thread.IsAlive )
 118                                 this.thread.Join();
 119                 }
 120
 121                 public void Cancel()
 122                 {
 123                         ThreadUtility.Kill(this.thread);
 124                 }
 125
 126                 public void StartRun( EventListener listener )
 127                 {
 128                         StartRun( listener, TestFilter.Empty );
 129                 }
 130
 131                 public void StartRun( EventListener listener, ITestFilter filter )
 132                 {
 133                         this.listener = listener;
 134                         this.filter = filter;
 135
 136                         thread.Start();
 137                 }
 138
 139                 #endregion
 140
 141                 #region Thread Proc
 142                 /// <summary>
 143                 /// The thread proc for our actual test run
 144                 /// </summary>
 145                 private void TestRunnerThreadProc()
 146                 {
 147             try
 148             {
 149                 results = new TestResult[] { runner.Run(this.listener, this.filter) };
 150             }
 151             catch (Exception ex)
 152             {
 153                 throw new ApplicationException("Exception in TestRunnerThread", ex);
 154             }
 155                 }
 156                 #endregion
 157         }
 158 }