nunit24/ClientUtilities/util/AggregatingTestRunner.cs

   1 // ****************************************************************
   2 // Copyright 2007, Charlie Poole
   3 // This is free software licensed under the NUnit license. You may
   4 // obtain a copy of the license at http://nunit.org/?p=license&r=2.4
   5 // ****************************************************************
   6
   7 //#define RUN_IN_PARALLEL
   8
   9 namespace NUnit.Util
  10 {
  11         using System;
  12         using System.Collections;
  13         using System.IO;
  14         using NUnit.Core;
  15
  16         /// <summary>
  17         /// AggregatingTestRunner allows running multiple TestRunners
  18         /// and combining the results.
  19         /// </summary>
  20         public abstract class AggregatingTestRunner : MarshalByRefObject, TestRunner, EventListener
  21         {
  22                 static int AggregateTestID = 1000;
  23
  24                 #region Instance Variables
  25
  26                 /// <summary>
  27                 /// Our runner ID
  28                 /// </summary>
  29                 protected int runnerID;
  30
  31                 /// <summary>
  32                 /// The downstream TestRunners
  33                 /// </summary>
  34                 protected ArrayList runners;
  35
  36                 /// <summary>
  37                 /// The loaded test suite
  38                 /// </summary>
  39                 protected TestNode aggregateTest;
  40
  41                 /// <summary>
  42                 /// The result of the last run
  43                 /// </summary>
  44                 private TestResult testResult;
  45
  46                 /// <summary>
  47                 /// The event listener for the currently running test
  48                 /// </summary>
  49                 protected EventListener listener;
  50
  51                 protected string projectName;
  52
  53                 protected TestName testName;
  54
  55                 #endregion
  56
  57                 #region Constructors
  58                 public AggregatingTestRunner() : this( 0 ) { }
  59                 public AggregatingTestRunner( int runnerID )
  60                 {
  61                         this.runnerID = runnerID;
  62                         this.testName = new TestName();
  63                         testName.TestID = new TestID( AggregateTestID );
  64                         testName.RunnerID = this.runnerID;
  65                         testName.FullName = testName.Name = "Not Loaded";
  66                 }
  67                 #endregion
  68
  69                 #region Properties
  70
  71                 public virtual int ID
  72                 {
  73                         get { return runnerID; }
  74                 }
  75
  76                 public virtual bool Running
  77                 {
  78                         get
  79                         {
  80                                 foreach( TestRunner runner in runners )
  81                                         if ( runner.Running )
  82                                                 return true;
  83
  84                                 return false;
  85                         }
  86                 }
  87
  88                 public virtual IList AssemblyInfo
  89                 {
  90                         get
  91                         {
  92                                 ArrayList info = new ArrayList();
  93                                 foreach( TestRunner runner in runners )
  94                                         info.AddRange( runner.AssemblyInfo );
  95                                 return info;
  96                         }
  97                 }
  98
  99                 public virtual ITest Test
 100                 {
 101                         get
 102                         {
 103                                 if ( aggregateTest == null && runners != null )
 104                                 {
 105                                         // Count non-null tests, in case we specified a fixture
 106                                         int count = 0;
 107                                         foreach( TestRunner runner in runners )
 108                                                 if ( runner.Test != null )
 109                                                         ++count;
 110
 111                                         // Copy non-null tests to an array
 112                                         int index = 0;
 113                                         ITest[] tests = new ITest[count];
 114                                         foreach( TestRunner runner in runners )
 115                                                 if ( runner.Test != null )
 116                                                         tests[index++] = runner.Test;
 117
 118                                         // Return master node containing all the tests
 119                                         aggregateTest = new TestNode( testName, tests );
 120                                 }
 121
 122                                 return aggregateTest;
 123                         }
 124                 }
 125
 126                 public virtual TestResult TestResult
 127                 {
 128                         get { return testResult; }
 129                 }
 130                 #endregion
 131
 132                 #region Load and Unload Methods
 133                 public abstract bool Load(TestPackage package);
 134
 135                 public virtual void Unload()
 136                 {
 137                         foreach( TestRunner runner in runners )
 138                                 runner.Unload();
 139                         aggregateTest = null;
 140                 }
 141                 #endregion
 142
 143                 #region CountTestCases
 144                 public virtual int CountTestCases( ITestFilter filter )
 145                 {
 146                         int count = 0;
 147                         foreach( TestRunner runner in runners )
 148                                 count += runner.CountTestCases( filter );
 149                         return count;
 150                 }
 151                 #endregion
 152
 153                 #region Methods for Running Tests
 154                 public virtual TestResult Run( EventListener listener )
 155                 {
 156                         return Run( listener, TestFilter.Empty );
 157                 }
 158
 159                 public virtual TestResult Run(EventListener listener, ITestFilter filter )
 160                 {
 161                         // Save active listener for derived classes
 162                         this.listener = listener;
 163
 164                         ITest[] tests = new ITest[runners.Count];
 165                         for( int index = 0; index < runners.Count; index++ )
 166                                 tests[index] = ((TestRunner)runners[index]).Test;
 167
 168                         this.listener.RunStarted( this.Test.TestName.Name, this.CountTestCases( filter ) );
 169
 170                         this.listener.SuiteStarted( this.Test.TestName );
 171                         long startTime = DateTime.Now.Ticks;
 172
 173                         TestSuiteResult result = new TestSuiteResult( new TestInfo( testName, tests ), projectName );
 174                         result.RunState = RunState.Executed;
 175                         foreach( TestRunner runner in runners )
 176                                 if ( filter.Pass( runner.Test ) )
 177                                         result.AddResult( runner.Run( this, filter ) );
 178
 179                         long stopTime = DateTime.Now.Ticks;
 180                         double time = ((double)(stopTime - startTime)) / (double)TimeSpan.TicksPerSecond;
 181                         result.Time = time;
 182
 183                         this.listener.SuiteFinished( result );
 184
 185                         this.listener.RunFinished( result );
 186
 187                         this.testResult = result;
 188
 189                         return result;
 190                 }
 191
 192                 public virtual void BeginRun( EventListener listener )
 193                 {
 194                         BeginRun( listener, TestFilter.Empty );
 195                 }
 196
 197                 public virtual void BeginRun( EventListener listener, ITestFilter filter )
 198                 {
 199                         // Save active listener for derived classes
 200                         this.listener = listener;
 201
 202 #if RUN_IN_PARALLEL
 203                         this.listener.RunStarted( this.Test.Name, this.CountTestCases( filter ) );
 204
 205                         foreach( TestRunner runner in runners )
 206                                 if ( runner.Test != null )
 207                                         runner.BeginRun( this, filter );
 208
 209                         //this.listener.RunFinished( this.Results );
 210 #else
 211                         ThreadedTestRunner threadedRunner = new ThreadedTestRunner( this );
 212                         threadedRunner.BeginRun( listener, filter );
 213 #endif
 214                 }
 215
 216                 public virtual TestResult EndRun()
 217                 {
 218                         TestSuiteResult suiteResult = new TestSuiteResult( aggregateTest, Test.TestName.FullName );
 219                         foreach( TestRunner runner in runners )
 220                                 suiteResult.Results.Add( runner.EndRun() );
 221
 222                         return suiteResult;
 223                 }
 224
 225                 public virtual void CancelRun()
 226                 {
 227                         foreach( TestRunner runner in runners )
 228                                 runner.CancelRun();
 229                 }
 230
 231                 public virtual void Wait()
 232                 {
 233                         foreach( TestRunner runner in runners )
 234                                 runner.Wait();
 235                 }
 236                 #endregion
 237
 238                 #region EventListener Members
 239                 public void TestStarted(TestName testName)
 240                 {
 241                         this.listener.TestStarted( testName );
 242                 }
 243
 244                 public void RunStarted(string name, int testCount)
 245                 {
 246                         // TODO: We may want to count how many runs are started
 247                         // Ignore - we provide our own
 248                 }
 249
 250                 public void RunFinished(Exception exception)
 251                 {
 252                         // Ignore - we provide our own
 253                 }
 254
 255                 void NUnit.Core.EventListener.RunFinished(TestResult result)
 256                 {
 257                         // TODO: Issue combined RunFinished when all runs are done
 258                 }
 259
 260                 public void SuiteFinished(TestSuiteResult result)
 261                 {
 262                         this.listener.SuiteFinished( result );
 263                 }
 264
 265                 public void TestFinished(TestCaseResult result)
 266                 {
 267                         this.listener.TestFinished( result );
 268                 }
 269
 270                 public void UnhandledException(Exception exception)
 271                 {
 272                         this.listener.UnhandledException( exception );
 273                 }
 274
 275                 public void TestOutput(TestOutput testOutput)
 276                 {
 277                         this.listener.TestOutput( testOutput );
 278                 }
 279
 280                 public void SuiteStarted(TestName suiteName)
 281                 {
 282                         this.listener.SuiteStarted( suiteName );
 283                 }
 284                 #endregion
 285
 286                 #region InitializeLifetimeService Override
 287                 public override object InitializeLifetimeService()
 288                 {
 289                         return null;
 290                 }
 291                 #endregion
 292         }
 293 }