TestCaseSourceAttribute is used on a parameterized test method to identify the property, method or field that will provide the required arguments. The attribute has two public constructors.
TestCaseSourceAttribute(Type sourceType, string sourceName); TestCaseSourceAttribute(string sourceName);
If sourceType is specified, it represents the class that provides the test cases. It must have a default constructor.
If sourceType 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.
The sourceName argument represents the name of the source used to provide test cases. It has the following characteristics:
In constructing tests, NUnit uses each item test case returned by the enumerator as follows:
If the test has a single argument and the returned value matches the type of that argument it is used directly.
If it is an object[], its elements are used to provide the arguments for the method, as in this example, which returns arguments from a named static field.
[Test, TestCaseSource("DivideCases")]
public void DivideTest(int n, int d, int q)
{
Assert.AreEqual( q, n / d );
}
static object[] DivideCases =
{
new object[] { 12, 3, 4 },
new object[] { 12, 2, 6 },
new object[] { 12, 4, 3 }
};
If it is an array of some other type, NUnit can use it provided that the arguments to the method are all of that type. For example, the above code could be modified to make the three nested arrays of type int[].
If it is a single value type - like numerics or DateTime - it is used directly as the sole argument to the method. The method must, of course take a single argument of the same type for this to work. This eliminates a bit of syntax on the part of the programmer, as in this example:
static int[] EvenNumbers = new int[] { 2, 4, 6, 8 };
[Test, TestCaseSource("EvenNumbers")]
public void TestMethod(int num)
{
Assert.IsTrue( num % 2 == 0 );
}
Note: Any user-defined struct intended to hold the arguments will be passed directly to the test method, since a struct is a value type. If you intend your user type to be used as described in the following item, you must define it as a class.
If it is any other type of object, it is examined using reflection and any public fields or properties with the following names are used:
Although any object with the required fields or properties may be used, NUnit provides the TestCaseData class for this purpose. The following example returns TestCaseData instances from a data source in a separately defined class.
[TestFixture]
public class MyTests
{
[Test,TestCaseSource(typeof(MyFactoryClass),"TestCases")]
public int DivideTest(int n, int d)
{
return n/d;
}
...
}
public class MyFactoryClass
{
public static IEnumerable TestCases
{
get
{
yield return new TestCaseData( 12, 3 ).Returns( 4 );
yield return new TestCaseData( 12, 2 ).Returns( 6 );
yield return new TestCaseData( 12, 4 ).Returns( 3 );
yield return new TestCaseData( 0, 0 )
.Throws(typeof(DivideByZeroException))
.SetName("DivideByZero")
.SetDescription("An exception is expected");
}
}
}
This example uses the fluent interface supported by TestCaseData to make the program more readable. The last yield statement above is equivalent to
TestCaseData data = new TestCaseData(0,0);
data.ExpectedException = typeof(DivideByZeroException;
data.TestName = "DivideByZero";
data.Description = "An exception is expected";
yield return data;
TestCaseData supports the following properties and methods, which may be appended to an instance in any order.
In NUnit 2.5, individual test cases are sorted alphabetically and executed in that order. With NUnit 2.5.1, the individual cases are not sorted, but are executed in the order in which NUnit discovers them. This order does not follow the lexical order of the attributes and will often vary between different compilers or different versions of the CLR.
As a result, when TestCaseSourceAttribute appears multiple times on a method or when other data-providing attributes are used in combination with TestCaseSourceAttribute, the order of the test cases is undefined.
However, when a single TestCaseSourceAttribute is used by itself, the order of the tests follows exactly the order in which the test cases are returned from the source.
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.
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.