nunit 2.5.0.9122 → 2.5.1.9189

data/docs/testCaseSource.html

@@ -40,7 +40,12 @@ TestCaseSourceAttribute(string sourceName);
 </div>
 
 <p>If <b>sourceType</b> is specified, it represents the class that provides
-the test cases. If not, the class containing the test method is used.
+the test cases. It must have a default constructor.
+
+<p>If <b>sourceType</b> is not specified, the class containing the test
+method is used. NUnit will construct it using either the default constructor
+or - if arguments are provided - the appropriate constructor for those 
+arguments.
 
 <p>The <b>sourceName</b> argument represents the name of the source used
 to provide test cases. It has the following characteristics:
@@ -53,7 +58,8 @@ to provide test cases. It has the following characteristics:
 	The rules for this are described in the next section.
 </ul>
 
-<h4>Constructing Test Cases</h4>
+<h3>Constructing Test Cases</h3>
+
 <p>In constructing tests, NUnit uses each item test case returned by
 the enumerator as follows:
 <ol>
@@ -126,7 +132,9 @@ and any public fields or properties with the following names are used:
   <dd>Provides a name for the test. If not specified, a name is generated based on 
       the method name and the arguments provided
   </dl>
-<p>
+
+<h3>TestCaseData Class</h3>
+
 <p>Although any object with the required fields or properties may be used,
    NUnit provides the <b>TestCaseData</b> class for this purpose. The following 
    example returns <b>TestCaseData</b> instances from a data source in
@@ -137,9 +145,9 @@ and any public fields or properties with the following names are used:
 public class MyTests
 {
   [Test,TestCaseSource(typeof(MyFactoryClass),"TestCases")]
-  public void DivideTest(int n, int d, int q)
+  public void DivideTest(int n, int d)
   {
-    Assert.AreEqual( q, n / d );
+    return n/d;
   }
 	
   ...
@@ -199,14 +207,19 @@ and methods, which may be appended to an instance in any order.
   <dd>Specifies a the Type or FullName of an exception that should be thrown by this invocation
 </dl>
 
-<h4>Note</h4>
+<h3>Note on Object Construction</h3>
+
 <p>NUnit locates the test cases at the time the tests are loaded, creates
 instances of each class with non-static sources and builds a list of 
 tests to be executed. Each source object is only created once at this
-time and is destroyed after all tests are loaded. In the case of test
-cases specified within the same class as the tests, a different object 
-is created each time the test is run, so no communication is possible 
-using non-static members of the class.
+time and is destroyed after all tests are loaded. 
+
+<p>If the data source is in the test fixture itself, the object is created
+using the appropriate constructor for the fixture parameters provided, or
+the default constructor if no parameters were specified. Since this object
+is destroyed before the tests are run, no communication is possible between
+these two phases - or between different runs - except through the parameters
+themselves.
 
    
 
@@ -215,7 +228,7 @@ using non-static members of the class.
 <!-- Submenu -->
 <div id="subnav">
 <ul>
-<li><a href="index.html">NUnit 2.5</a></li>
+<li><a href="index.html">NUnit 2.5.1</a></li>
 <ul>
 <li><a href="getStarted.html">Getting&nbsp;Started</a></li>
 <li><a href="assertions.html">Assertions</a></li>

data/docs/testDecorators.html

@@ -72,7 +72,7 @@ standard values are defined for use if desired:
 <!-- Submenu -->
 <div id="subnav">
 <ul>
-<li><a href="index.html">NUnit 2.5</a></li>
+<li><a href="index.html">NUnit 2.5.1</a></li>
 <ul>
 <li><a href="getStarted.html">Getting&nbsp;Started</a></li>
 <li><a href="assertions.html">Assertions</a></li>

data/docs/testFixture.html

@@ -49,7 +49,7 @@
    since NUnit may construct the object multiple times in the course of a session.</li>
 
 <p>Beginning with NUnit 2.5, the <b>TestFixture</b> attribute is optional
-   for non-paramterized, non-generic fixtures, so long as the class contains
+   for non-parameterized, non-generic fixtures, so long as the class contains
    at least one method marked with the <b>Test</b>,
    <b>TestCase</b> or <b>TestCaseSource</b> attribute.
 
@@ -232,7 +232,7 @@ public class IList_Tests&lt;TList&gt; where TList : IList, new()
 <div class="code"><pre>
 [TestFixture(typeof(double), typeof(int), 100.0, 42)]
 [TestFixture(typeof(int) typeof(double), 42, 100.0)]
-public class SpecifyBothSetsOfArgs<T1, T2>
+public class SpecifyBothSetsOfArgs&lt;T1, T2&gt;
 {
     T1 t1;
     T2 t2;
@@ -246,8 +246,8 @@ public class SpecifyBothSetsOfArgs<T1, T2>
     [TestCase(5, 7)]
     public void TestMyArgTypes(T1 t1, T2 t2)
     {
-        Assert.That(t1, Is.TypeOf<T1>());
-        Assert.That(t2, Is.TypeOf<T2>());
+        Assert.That(t1, Is.TypeOf&lt;T1&gt;());
+        Assert.That(t2, Is.TypeOf&lt;T2&gt;());
     }
 }</pre></div>
 
@@ -259,7 +259,7 @@ public class SpecifyBothSetsOfArgs<T1, T2>
 <div class="code" style="width: 40em"><pre>
 [TestFixture(100.0, 42, TypeArgs=new Type[] {typeof(double), typeof(int) } )]
 [TestFixture(42, 100.0, TypeArgs=new Type[] {typeof(int), typeof(double) } )]
-public class SpecifyTypeArgsSeparately<T1, T2>
+public class SpecifyTypeArgsSeparately&lt;T1, T2&gt;
 {
     T1 t1;
     T2 t2;
@@ -273,8 +273,8 @@ public class SpecifyTypeArgsSeparately<T1, T2>
     [TestCase(5, 7)]
     public void TestMyArgTypes(T1 t1, T2 t2)
     {
-        Assert.That(t1, Is.TypeOf<T1>());
-        Assert.That(t2, Is.TypeOf<T2>());
+        Assert.That(t1, Is.TypeOf&lt;T1&gt;());
+        Assert.That(t2, Is.TypeOf&lt;T2&gt;());
     }
 }</pre></div>
 
@@ -286,7 +286,7 @@ public class SpecifyTypeArgsSeparately<T1, T2>
 <div class="code"><pre>
 [TestFixture(100.0, 42)]
 [TestFixture(42, 100.0)]
-public class DeduceTypeArgsFromArgs<T1, T2>
+public class DeduceTypeArgsFromArgs&lt;T1, T2&gt;
 {
     T1 t1;
     T2 t2;
@@ -300,8 +300,8 @@ public class DeduceTypeArgsFromArgs<T1, T2>
     [TestCase(5, 7)]
     public void TestMyArgTypes(T1 t1, T2 t2)
     {
-        Assert.That(t1, Is.TypeOf<T1>());
-        Assert.That(t2, Is.TypeOf<T2>());
+        Assert.That(t1, Is.TypeOf&lt;T1&gt;());
+        Assert.That(t2, Is.TypeOf&lt;T2&gt;());
     }
 }</pre></div>
    </ol> 
@@ -311,7 +311,7 @@ public class DeduceTypeArgsFromArgs<T1, T2>
 <!-- Submenu -->
 <div id="subnav">
 <ul>
-<li><a href="index.html">NUnit 2.5</a></li>
+<li><a href="index.html">NUnit 2.5.1</a></li>
 <ul>
 <li><a href="getStarted.html">Getting&nbsp;Started</a></li>
 <li><a href="assertions.html">Assertions</a></li>

data/docs/testProperties.html

@@ -39,7 +39,7 @@ which causes it to remain open as the user clicks on different tests.</p>
 <!-- Submenu -->
 <div id="subnav">
 <ul>
-<li><a href="index.html">NUnit 2.5</a></li>
+<li><a href="index.html">NUnit 2.5.1</a></li>
 <ul>
 <li><a href="getStarted.html">Getting&nbsp;Started</a></li>
 <li><a href="assertions.html">Assertions</a></li>

data/docs/testcaseBuilders.html

@@ -72,7 +72,7 @@ provided as an argument or null if the method cannot be used.
 <!-- Submenu -->
 <div id="subnav">
 <ul>
-<li><a href="index.html">NUnit 2.5</a></li>
+<li><a href="index.html">NUnit 2.5.1</a></li>
 <ul>
 <li><a href="getStarted.html">Getting&nbsp;Started</a></li>
 <li><a href="assertions.html">Assertions</a></li>

data/docs/testcaseProviders.html

@@ -37,7 +37,8 @@ specific test cases that will be used in calling the test.
 	IExtensionPoint listeners = host.GetExtensionPoint( "ParameterProviders" );</pre>
 
 <h4>Interface</h4>
-<p>The extension object passed to Install must implement the ITestCaseProvider interface:
+<p>The extension object passed to Install must implement either the 
+   <b>ITestCaseProvider</b> or the <b>ITestCaseProvider2</b> interface:
 
 <pre>
 	public interface ITestCaseProvider
@@ -45,12 +46,21 @@ specific test cases that will be used in calling the test.
 		bool HasTestCasesFor( MethodInfo method );
 		IEnumerable GetTestCasesFor( MethodInfo method );
 	}
+	
+	public interface ITestCaseProvider2 : ITestCaseProvider
+	{
+		bool HasTestCasesFor( MethodInfo method, Test suite );
+		IEnumerable GetTestCasesFor( MethodInfo method, Test suite );
+	}
 </pre>
 
-<p>HasTestCasesFor returns true if the provider is able to supply test cases
+<p>NUnit will call <b>ITestCaseProvider2</b> if it is available. Otherwise
+   <b>ITestCaseProvider</b> will be used.
+
+<p><b>HasTestCasesFor</b> should return true if the provider is able to supply test cases
    for the specified method. If a provider only wants to be used on certain types 
-   of tests, it should examine the provided MethodInfo and return true or false
-   based on what it finds.
+   of tests, it can examine the provided MethodInfo and the suite for which the
+   test is being constructed and return true or false based on what it finds.
 
 <p>The GetParametersFor method should return a list of individual test cases.
    Each test case may be expressed as a ParameterSet, as an array of arguments
@@ -70,6 +80,19 @@ specific test cases that will be used in calling the test.
 
 <p>The ParameterSet class provides all these properties and may be used
 to avoid the overhead of reflecting on the properties.
+
+<h4>Notes:</h4>
+
+<ol>
+<li>Most providers will delegate one of the interface implementations
+    to the other if they implement both.
+<li>TestCaseProviders that use data from the fixture class should use 
+    <b>ITestCaseProvider2</b> interface so that they are able to access any 
+	arguments supplied for constructing the fixture object.
+<li>Providers that acquire data from outside the fixture will usually
+    be able to work with <b>ITestCaseProvider</b> alone.
+<li>The <b>ITestCaseProvider2</b> interface was added in the NUnit 2.5.1 release.
+</ol>
    
 
 </div>
@@ -77,7 +100,7 @@ to avoid the overhead of reflecting on the properties.
 <!-- Submenu -->
 <div id="subnav">
 <ul>
-<li><a href="index.html">NUnit 2.5</a></li>
+<li><a href="index.html">NUnit 2.5.1</a></li>
 <ul>
 <li><a href="getStarted.html">Getting&nbsp;Started</a></li>
 <li><a href="assertions.html">Assertions</a></li>

data/docs/theory.html

@@ -139,7 +139,7 @@ public class SqrtTests
 <!-- Submenu -->
 <div id="subnav">
 <ul>
-<li><a href="index.html">NUnit 2.5</a></li>
+<li><a href="index.html">NUnit 2.5.1</a></li>
 <ul>
 <li><a href="getStarted.html">Getting&nbsp;Started</a></li>
 <li><a href="assertions.html">Assertions</a></li>

data/docs/throwsConstraint.html

@@ -26,46 +26,75 @@
 
 <h2>Throws Constraint (NUnit 2.5)</h2>
 
-<p>ThrowsConstraint is used to test that some code, represented as a delegate,
+<p><b>ThrowsConstraint</b> is used to test that some code, represented as a delegate,
 throws a particular exception. It may be used alone, to merely test the type
 of constraint, or with an additional constraint to be applied to the exception
 specified as an argument.
 
-<table class="constraints">
-<tr><th>Syntax Helper</th><th>Constructor</th><th>Operation</th></tr>
-<tr><td>Throws.Exception(Type)</td><td>ThrowsConstraint(Type)</td></td><td>tests that an exception of the specified type is thrown</td></tr>
-<tr><td>Throws.Exception(Type,Constraint)</td><td>ThrowsConstraint(Type,Constraint)</td></td><td>tests that an exception of the specified type is thrown and that it satisifies the constrant provided as the second argument</td></tr>
-<tr><td>Throws.Exception&lt;T&gt;()</td><td>ThrowsConstraint&lt;T&gt;()</td></td><td>tests that an exception of the specified type is thrown</td></tr>
-<tr><td>Throws.Exception&lt;T&gt;(Constraint)</td><td>ThrowsConstraint&lt;T&gt;(Constraint)</td></td><td>tests that an exception of the specified type is thrown and that it satisifies the constrant provided as an argument</td></tr>
-</table>
+p>The related <b>ThrowsNothingConstraint</b> simply asserts that the delegate
+does not throw an exception.
 
-<h4>Examples</h4>
+<h4>Constructors</h4>
+<div class="code"><pre>
+ThrowsConstraint(Type expectedType)
+ThrowsConstraint&lt;T&gt;()
+ThrowsConstraint(Type expectedType, Constraint constraint)
+ThrowsConstraint&lt;T&gt;(Constraint constraint)
+ThrowsNothingConstraint()
+</pre></div>
 
+<h4>Syntax</h4>
 <div class="code"><pre>
+Throws.Exception
+Throws.TypeOf(Type expectedType)
+Throws.TypeOf&lt;T&gt;()
+Throws.InstanceOf(Type expectedType)
+Throws.InstanceOf&lt;T&gt;()
+Throws.Nothing
+</pre></div>
 
+<h4>Examples of Use</h4>
+<div class="code"><pre>
 // .NET 1.1
 Assert.That( new TestDelegate(SomeMethod),
-  Throws.Exception(typeof(ArgumentException)));
+  Throws.TypeOf(typeof(ArgumentException)));
+Assert.That( new TestDelegate(SomeMethod),
+  Throws.Exception.TypeOf(typeof(ArgumentException)));
 Assert.That( new TestDelegate(SomeMethod),
-  Throws.Exception(typeof(ArgumentException),
-    Has.Property("Parameter", "myParam")));
+  Throws.TypeOf(typeof(ArgumentException))
+    .With.Property("Parameter").EqualTo("myParam"));
 	
 // .NET 2.0
 Assert.That( SomeMethod, 
-  Throws.Exception&lt;ArgumentException&gt;());
+  Throws.TypeOf&lt;ArgumentException&gt;());
 Assert.That( SomeMethod, 
-  Throws.Exception&lt;ArgumentException&gt;(
-    Has.Property("Parameter", "myParam")));
-
+  Throws.Exception.TypeOf&lt;ArgumentException&gt;());
+Assert.That( SomeMethod, 
+  Throws.TypeOf&lt;ArgumentException&gt;()
+    .With.Property("Parameter").EqualTo("myParam"));
 </pre></div>
 
+<h4>Notes</h4>
+<ol>
+<li><b>Throws.Exception</b> may be followed by further constraints,
+    which are applied to the exception itself as shown in the last two
+	examples above. It may also be used alone to verify that some
+	exception has been thrown, without regard to type. This is
+	not a recommended practice since you should normally know
+	what exception you are expecting.
+<li><b>Throws.TypeOf</b> and <b>Throws.InstanceOf</b> are provided
+    as a shorter syntax for this common test. They work exactly like
+	the corresponding forms following <b>Throws.Exception</b>.
+</ol>
+
+
 
 </div>
 
 <!-- Submenu -->
 <div id="subnav">
 <ul>
-<li><a href="index.html">NUnit 2.5</a></li>
+<li><a href="index.html">NUnit 2.5.1</a></li>
 <ul>
 <li><a href="getStarted.html">Getting&nbsp;Started</a></li>
 <li><a href="assertions.html">Assertions</a></li>

data/docs/timeout.html

@@ -40,7 +40,7 @@
 <!-- Submenu -->
 <div id="subnav">
 <ul>
-<li><a href="index.html">NUnit 2.5</a></li>
+<li><a href="index.html">NUnit 2.5.1</a></li>
 <ul>
 <li><a href="getStarted.html">Getting&nbsp;Started</a></li>
 <li><a href="assertions.html">Assertions</a></li>

data/docs/typeAsserts.html

@@ -89,7 +89,7 @@ Assert.IsNotAssignableFrom<T>( object actual,
 <!-- Submenu -->
 <div id="subnav">
 <ul>
-<li><a href="index.html">NUnit 2.5</a></li>
+<li><a href="index.html">NUnit 2.5.1</a></li>
 <ul>
 <li><a href="getStarted.html">Getting&nbsp;Started</a></li>
 <li><a href="assertions.html">Assertions</a></li>

data/docs/typeConstraints.html

@@ -59,7 +59,7 @@ Expect( "Hello", AssignableFrom(typeOf(string)));
 <!-- Submenu -->
 <div id="subnav">
 <ul>
-<li><a href="index.html">NUnit 2.5</a></li>
+<li><a href="index.html">NUnit 2.5.1</a></li>
 <ul>
 <li><a href="getStarted.html">Getting&nbsp;Started</a></li>
 <li><a href="assertions.html">Assertions</a></li>

data/docs/upgrade.html

@@ -64,7 +64,7 @@ in order for your tests to load correctly.
 <!-- Submenu -->
 <div id="subnav">
 <ul>
-<li><a href="index.html">NUnit 2.5</a></li>
+<li><a href="index.html">NUnit 2.5.1</a></li>
 <ul>
 <li><a href="getStarted.html">Getting&nbsp;Started</a></li>
 <ul>

data/docs/utilityAsserts.html

@@ -85,7 +85,7 @@ public void AssertStringContains( string expected, string actual,
 <!-- Submenu -->
 <div id="subnav">
 <ul>
-<li><a href="index.html">NUnit 2.5</a></li>
+<li><a href="index.html">NUnit 2.5.1</a></li>
 <ul>
 <li><a href="getStarted.html">Getting&nbsp;Started</a></li>
 <li><a href="assertions.html">Assertions</a></li>

data/docs/valueSource.html

@@ -40,7 +40,12 @@ ValueSourceAttribute(string sourceName);
 </div>
 
 <p>If <b>sourceType</b> is specified, it represents the class that provides
-the data. If not, the class containing the test method is used.
+the data. It must have a default constructor.
+
+<p>If <b>sourceType</b> is not specified, the class containing the test
+method is used. NUnit will construct it using either the default constructor
+or - if arguments are provided - the appropriate constructor for those 
+arguments.
 
 <p>The <b>sourceName</b>, represents the name of the source that will 
 provide the arguments. It should have the following characteristics:
@@ -53,22 +58,26 @@ provide the arguments. It should have the following characteristics:
 <li>
 </ul>
 
-<p>NUnit locates value sources at the time the tests are loaded, creates
-instances of each class having non-static sources and builds a list of 
-tests to be executed. Each instance is only created once at this
-time and is destroyed after all tests are loaded. In the case of sources
-located within the same class as the tests, a different instance is created
-each time the test is run, so no communication is possible using non-static
-members of the class.
+<h3>Note on Object Construction</h3>
+
+<p>NUnit locates the test cases at the time the tests are loaded, creates
+instances of each class with non-static sources and builds a list of 
+tests to be executed. Each source object is only created once at this
+time and is destroyed after all tests are loaded. 
 
-   
+<p>If the data source is in the test fixture itself, the object is created
+using the appropriate constructor for the fixture parameters provided, or
+the default constructor if no parameters were specified. Since this object
+is destroyed before the tests are run, no communication is possible between
+these two phases - or between different runs - except through the parameters
+themselves.
 
 </div>
 
 <!-- Submenu -->
 <div id="subnav">
 <ul>
-<li><a href="index.html">NUnit 2.5</a></li>
+<li><a href="index.html">NUnit 2.5.1</a></li>
 <ul>
 <li><a href="getStarted.html">Getting&nbsp;Started</a></li>
 <li><a href="assertions.html">Assertions</a></li>