nunit24/NUnitCore/interfaces/Test.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 namespace NUnit.Core
   8 {
   9         using System;
  10         using System.Collections;
  11         using System.Collections.Specialized;
  12         using System.Reflection;
  13
  14         /// <summary>
  15         ///             Test Class.
  16         /// </summary>
  17         public abstract class Test : ITest, IComparable
  18         {
  19                 #region Fields
  20                 /// <summary>
  21                 /// TestName that identifies this test
  22                 /// </summary>
  23                 private TestName testName;
  24
  25                 /// <summary>
  26                 /// Indicates whether the test should be executed
  27                 /// </summary>
  28                 private RunState runState;
  29
  30                 /// <summary>
  31                 /// The reason for not running the test
  32                 /// </summary>
  33                 private string ignoreReason;
  34
  35                 /// <summary>
  36                 /// Description for this test
  37                 /// </summary>
  38                 private string description;
  39
  40                 /// <summary>
  41                 /// Test suite containing this test, or null
  42                 /// </summary>
  43                 private Test parent;
  44
  45                 /// <summary>
  46                 /// List of categories applying to this test
  47                 /// </summary>
  48                 private IList categories;
  49
  50                 /// <summary>
  51                 /// A dictionary of properties, used to add information
  52                 /// to tests without requiring the class to change.
  53                 /// </summary>
  54                 private IDictionary properties;
  55
  56                 /// <summary>
  57                 /// The System.Type of the fixture for this test suite, if there is one
  58                 /// </summary>
  59                 private Type fixtureType;
  60
  61                 /// <summary>
  62                 /// The fixture object, if it has been created
  63                 /// </summary>
  64                 private object fixture;
  65
  66                 #endregion
  67
  68                 #region Construction
  69
  70                 /// <summary>
  71                 /// Constructs a test given its name
  72                 /// </summary>
  73                 /// <param name="name">The name of the test</param>
  74                 protected Test( string name )
  75                 {
  76                         this.testName = new TestName();
  77                         this.testName.FullName = name;
  78                         this.testName.Name = name;
  79                         this.testName.TestID = new TestID();
  80
  81             this.runState = RunState.Runnable;
  82                 }
  83
  84                 /// <summary>
  85                 /// Constructs a test given the path through the
  86                 /// test hierarchy to its parent and a name.
  87                 /// </summary>
  88                 /// <param name="pathName">The parent tests full name</param>
  89                 /// <param name="name">The name of the test</param>
  90                 protected Test( string pathName, string name )
  91                 {
  92                         this.testName = new TestName();
  93                         this.testName.FullName = pathName == null || pathName == string.Empty
  94                                 ? name : pathName + "." + name;
  95                         this.testName.Name = name;
  96                         this.testName.TestID = new TestID();
  97
  98             this.runState = RunState.Runnable;
  99                 }
 100
 101                 /// <summary>
 102                 /// Constructs a test given a TestName object
 103                 /// </summary>
 104                 /// <param name="testName">The TestName for this test</param>
 105                 protected Test( TestName testName )
 106                 {
 107                         this.testName = testName;
 108
 109                         this.runState = RunState.Runnable;
 110                 }
 111
 112                 /// <summary>
 113                 /// Constructs a test given a fixture type
 114                 /// </summary>
 115                 /// <param name="fixtureType">The type to use in constructiong the test</param>
 116                 protected Test( Type fixtureType )
 117                 {
 118                         this.testName = new TestName();
 119                         this.testName.FullName = fixtureType.FullName;
 120                         this.testName.Name = fixtureType.Namespace != null
 121                                 ? TestName.FullName.Substring( TestName.FullName.LastIndexOf( '.' ) + 1 )
 122                                 : fixtureType.FullName;
 123                         this.testName.TestID = new TestID();
 124
 125                         this.fixtureType = fixtureType;
 126                         this.RunState = RunState.Runnable;
 127                 }
 128
 129                 /// <summary>
 130                 /// Construct a test given a MethodInfo
 131                 /// </summary>
 132                 /// <param name="method">The method to be used</param>
 133                 protected Test( MethodInfo method )
 134                         : this( method.ReflectedType )
 135                 {
 136                         this.testName.Name = method.DeclaringType == method.ReflectedType
 137                                 ? method.Name : method.DeclaringType.Name + "." + method.Name;
 138                         this.testName.FullName = method.ReflectedType.FullName + "." + method.Name;
 139                 }
 140
 141                 /// <summary>
 142                 /// Sets the runner id of a test and optionally its children
 143                 /// </summary>
 144                 /// <param name="runnerID">The runner id to be used</param>
 145                 /// <param name="recursive">True if all children should get the same id</param>
 146                 public void SetRunnerID( int runnerID, bool recursive )
 147                 {
 148                         this.testName.RunnerID = runnerID;
 149
 150                         if ( recursive && this.Tests != null )
 151                                 foreach( Test child in this.Tests )
 152                                         child.SetRunnerID( runnerID, true );
 153                 }
 154
 155                 #endregion
 156
 157                 #region ITest Members
 158
 159         #region Properties
 160                 /// <summary>
 161                 /// Gets the TestName of the test
 162                 /// </summary>
 163         public TestName TestName
 164                 {
 165                         get { return testName; }
 166                 }
 167
 168                 /// <summary>
 169                 /// Gets a string representing the kind of test
 170                 /// that this object represents, for use in display.
 171                 /// </summary>
 172                 public abstract string TestType { get; }
 173
 174                 /// <summary>
 175                 /// Whether or not the test should be run
 176                 /// </summary>
 177         public RunState RunState
 178         {
 179             get { return runState; }
 180             set { runState = value; }
 181         }
 182
 183                 /// <summary>
 184                 /// Reason for not running the test, if applicable
 185                 /// </summary>
 186                 public string IgnoreReason
 187                 {
 188                         get { return ignoreReason; }
 189                         set { ignoreReason = value; }
 190                 }
 191
 192                 /// <summary>
 193                 /// Gets a count of test cases represented by
 194                 /// or contained under this test.
 195                 /// </summary>
 196                 public virtual int TestCount
 197                 {
 198                         get { return 1; }
 199                 }
 200
 201                 /// <summary>
 202                 /// Gets a list of categories associated with this test.
 203                 /// </summary>
 204                 public IList Categories
 205                 {
 206                         get { return categories; }
 207                         set { categories = value; }
 208                 }
 209
 210                 /// <summary>
 211                 /// Gets a desctiption associated with this test.
 212                 /// </summary>
 213                 public String Description
 214                 {
 215                         get { return description; }
 216                         set { description = value; }
 217                 }
 218
 219                 /// <summary>
 220                 /// Gets the property dictionary for this test
 221                 /// </summary>
 222                 public IDictionary Properties
 223                 {
 224                         get
 225                         {
 226                                 if ( properties == null )
 227                                         properties = new ListDictionary();
 228
 229                                 return properties;
 230                         }
 231                         set
 232                         {
 233                                 properties = value;
 234                         }
 235                 }
 236
 237                 /// <summary>
 238                 /// Indicates whether this test is a suite
 239                 /// </summary>
 240                 public abstract bool IsSuite { get; }
 241
 242                 /// <summary>
 243                 /// Gets the parent test of this test
 244                 /// </summary>
 245                 ITest ITest.Parent
 246                 {
 247                         get { return parent; }
 248                 }
 249
 250                 /// <summary>
 251                 /// Gets the parent as a Test object.
 252                 /// Used by the core to set the parent.
 253                 /// </summary>
 254                 public Test Parent
 255                 {
 256                         get { return parent; }
 257                         set { parent = value; }
 258                 }
 259
 260                 /// <summary>
 261                 /// Gets this test's child tests
 262                 /// </summary>
 263                 public abstract IList Tests { get; }
 264
 265                 /// <summary>
 266                 /// Gets the Type of the fixture used in running this test
 267                 /// </summary>
 268                 public Type FixtureType
 269                 {
 270                         get { return fixtureType; }
 271                 }
 272
 273                 /// <summary>
 274                 /// Gets or sets a fixture object for running this test
 275                 /// </summary>
 276                 public  object Fixture
 277                 {
 278                         get { return fixture; }
 279                         set { fixture = value; }
 280         }
 281         #endregion
 282
 283         #region Methods
 284                 /// <summary>
 285                 /// Gets a count of test cases that would be run using
 286                 /// the specified filter.
 287                 /// </summary>
 288                 /// <param name="filter"></param>
 289                 /// <returns></returns>
 290         public abstract int CountTestCases(ITestFilter filter);
 291         #endregion
 292
 293         #endregion
 294
 295                 #region Abstract Run Methods
 296                 /// <summary>
 297                 /// Runs the test, sending notifications to a listener.
 298                 /// </summary>
 299                 /// <param name="listener">An event listener to receive notifications</param>
 300                 /// <returns>A TestResult</returns>
 301                 public abstract TestResult Run(EventListener listener);
 302
 303                 /// <summary>
 304                 /// Runs the test under a particular filter, sending
 305                 /// notifications to a listener.
 306                 /// </summary>
 307                 /// <param name="listener">An event listener to receive notifications</param>
 308                 /// <param name="filter">A filter used in running the test</param>
 309                 /// <returns></returns>
 310         public abstract TestResult Run(EventListener listener, ITestFilter filter);
 311                 #endregion
 312
 313                 #region IComparable Members
 314                 /// <summary>
 315                 /// Compares this test to another test for sorting purposes
 316                 /// </summary>
 317                 /// <param name="obj">The other test</param>
 318                 /// <returns>Value of -1, 0 or +1 depending on whether the current test is less than, equal to or greater than the other test</returns>
 319                 public int CompareTo(object obj)
 320                 {
 321                         Test other = obj as Test;
 322
 323                         if ( other == null )
 324                                 return -1;
 325
 326                         return this.TestName.FullName.CompareTo( other.TestName.FullName );
 327                 }
 328                 #endregion
 329         }
 330 }