public override IEnumerable GetTestCases()
{
ArrayList testCases = new ArrayList();
#endif
IEnumerator[] enumerators = new IEnumerator[Sources.Length];
int index = -1;
for (; ; )
{
while (++index < Sources.Length)
{
enumerators[index] = Sources[index].GetEnumerator();
if (!enumerators[index].MoveNext())
return testCases;
}
object[] testdata = new object[Sources.Length];
for (int i = 0; i < Sources.Length; i++)
testdata[i] = enumerators[i].Current;
ParameterSet parms = new ParameterSet();
parms.Arguments = testdata;
testCases.Add(parms);
index = Sources.Length;
while (--index >= 0 && !enumerators[index].MoveNext()) ;
if (index < 0) break;
}
return testCases;
}
public override IEnumerable GetTestCases()
{
ArrayList testCases = new ArrayList();
#endif
for (; ; )
{
bool gotData = false;
object[] testdata = new object[Sources.Length];
for (int i = 0; i < Sources.Length; i++)
if (Enumerators[i].MoveNext())
{
testdata[i] = Enumerators[i].Current;
gotData = true;
}
else
testdata[i] = null;
if (!gotData)
break;
ParameterSet parms = new ParameterSet();
parms.Arguments = testdata;
testCases.Add(parms);
}
return testCases;
}
/// <summary>
/// Returns an collection containing a single ITestCaseData item,
/// constructed from the arguments provided in the constructor and
/// possibly converted to match the specified method.
/// </summary>
/// <param name="method">The method for which data is being provided</param>
/// <returns></returns>
public System.Collections.Generic.IEnumerable<ITestCaseData> GetTestCasesFor(System.Reflection.MethodInfo method)
{
ParameterSet parms;
try
{
ParameterInfo[] parameters = method.GetParameters();
int argsNeeded = parameters.Length;
int argsProvided = Arguments.Length;
parms = new ParameterSet(this);
// Special handling for params arguments
if (argsNeeded > 0 && argsProvided >= argsNeeded - 1)
{
ParameterInfo lastParameter = parameters[argsNeeded - 1];
Type lastParameterType = lastParameter.ParameterType;
Type elementType = lastParameterType.GetElementType();
if (lastParameterType.IsArray && lastParameter.IsDefined(typeof(ParamArrayAttribute), false))
{
if (argsProvided == argsNeeded)
{
Type lastArgumentType = parms.Arguments[argsProvided - 1].GetType();
if (!lastParameterType.IsAssignableFrom(lastArgumentType))
{
Array array = Array.CreateInstance(elementType, 1);
array.SetValue(parms.Arguments[argsProvided - 1], 0);
parms.Arguments[argsProvided - 1] = array;
}
}
else
{
object[] newArglist = new object[argsNeeded];
for (int i = 0; i < argsNeeded && i < argsProvided; i++)
newArglist[i] = parms.Arguments[i];
int length = argsProvided - argsNeeded + 1;
Array array = Array.CreateInstance(elementType, length);
for (int i = 0; i < length; i++)
array.SetValue(parms.Arguments[argsNeeded + i - 1], i);
newArglist[argsNeeded - 1] = array;
parms.Arguments = newArglist;
argsProvided = argsNeeded;
}
}
}
//if (method.GetParameters().Length == 1 && method.GetParameters()[0].ParameterType == typeof(object[]))
// parms.Arguments = new object[]{parms.Arguments};
// Special handling when sole argument is an object[]
if (argsNeeded == 1 && method.GetParameters()[0].ParameterType == typeof(object[]))
{
if (argsProvided > 1 ||
argsProvided == 1 && parms.Arguments[0].GetType() != typeof(object[]))
{
parms.Arguments = new object[] { parms.Arguments };
}
}
if (argsProvided == argsNeeded)
PerformSpecialConversions(parms.Arguments, parameters);
}
catch (Exception ex)
{
parms = new ParameterSet(ex);
}
return new ITestCaseData[] { parms };
}
public IEnumerable GetTestCasesFor(MethodInfo method)
{
ArrayList data = new ArrayList();
#endif
IEnumerable source = GetTestCaseSource(method);
if (source != null)
{
ParameterInfo[] parameters = method.GetParameters();
foreach (object item in source)
{
ParameterSet parms = new ParameterSet();
ITestCaseData testCaseData = item as ITestCaseData;
if (testCaseData != null)
parms = new ParameterSet(testCaseData);
else if (item is object[])
{
object[] array = item as object[];
parms.Arguments = array.Length == parameters.Length
? array
: new object[] { item };
}
//else if (parameters.Length == 1 && parameters[0].ParameterType.IsAssignableFrom(item.GetType()))
//{
// parms.Arguments = new object[] { item };
//}
else if (item is Array)
{
Array array = item as Array;
if (array.Rank == 1 && array.Length == parameters.Length)
{
parms.Arguments = new object[array.Length];
for (int i = 0; i < array.Length; i++)
parms.Arguments[i] = (object)array.GetValue(i);
}
else
{
parms.Arguments = new object[] { item };
}
}
else
{
parms.Arguments = new object[] { item };
}
if (this.Category != null)
foreach (string cat in this.Category.Split(new char[] { ',' }))
parms.Properties.Add(PropertyNames.Category, cat);
data.Add(parms);
}
}
return data;
}
/// <summary>
/// Construct a TestMethod from a given MethodInfo.
/// </summary>
/// <param name="method">The MethodInfo for which a test is to be constructed.</param>
/// <param name="suite">The suite to which the test will be added.</param>
/// <returns>A TestMethod</returns>
public TestMethod BuildFrom(MethodInfo method, Test suite)
{
ParameterSet parms = null;
if (this.HasExpectedResult)
{
parms = new ParameterSet();
parms.ExpectedResult = this.ExpectedResult;
}
return _builder.BuildTestMethod(method, suite, parms);
}
private ParameterSet GetParametersForTestCase(MethodInfo method)
{
ParameterSet parms;
try
{
#if NETCF
var tmethod = method.MakeGenericMethodEx(Arguments);
if (tmethod == null)
throw new NotSupportedException("Cannot determine generic types from probing");
method = tmethod;
#endif
ParameterInfo[] parameters = method.GetParameters();
int argsNeeded = parameters.Length;
int argsProvided = Arguments.Length;
parms = new ParameterSet(this);
// Special handling for params arguments
if (argsNeeded > 0 && argsProvided >= argsNeeded - 1)
{
ParameterInfo lastParameter = parameters[argsNeeded - 1];
Type lastParameterType = lastParameter.ParameterType;
Type elementType = lastParameterType.GetElementType();
if (lastParameterType.IsArray && lastParameter.IsDefined(typeof(ParamArrayAttribute), false))
{
if (argsProvided == argsNeeded)
{
Type lastArgumentType = parms.Arguments[argsProvided - 1].GetType();
if (!lastParameterType.IsAssignableFrom(lastArgumentType))
{
Array array = Array.CreateInstance(elementType, 1);
array.SetValue(parms.Arguments[argsProvided - 1], 0);
parms.Arguments[argsProvided - 1] = array;
}
}
else
{
object[] newArglist = new object[argsNeeded];
for (int i = 0; i < argsNeeded && i < argsProvided; i++)
newArglist[i] = parms.Arguments[i];
int length = argsProvided - argsNeeded + 1;
Array array = Array.CreateInstance(elementType, length);
for (int i = 0; i < length; i++)
array.SetValue(parms.Arguments[argsNeeded + i - 1], i);
newArglist[argsNeeded - 1] = array;
parms.Arguments = newArglist;
argsProvided = argsNeeded;
}
}
}
//if (method.GetParameters().Length == 1 && method.GetParameters()[0].ParameterType == typeof(object[]))
// parms.Arguments = new object[]{parms.Arguments};
// Special handling when sole argument is an object[]
if (argsNeeded == 1 && method.GetParameters()[0].ParameterType == typeof(object[]))
{
if (argsProvided > 1 ||
argsProvided == 1 && parms.Arguments[0].GetType() != typeof(object[]))
{
parms.Arguments = new object[] { parms.Arguments };
}
}
if (argsProvided == argsNeeded)
PerformSpecialConversions(parms.Arguments, parameters);
}
catch (Exception ex)
{
parms = new ParameterSet(ex);
}
return parms;
}
/// <summary>
/// Builds a single NUnitTestMethod, either as a child of the fixture
/// or as one of a set of test cases under a ParameterizedTestMethodSuite.
/// </summary>
/// <param name="method">The MethodInfo from which to construct the TestMethod</param>
/// <param name="parentSuite">The suite or fixture to which the new test will be added</param>
/// <param name="parms">The ParameterSet to be used, or null</param>
/// <returns></returns>
private TestMethod BuildSingleTestMethod(MethodInfo method, Test parentSuite, ParameterSet parms)
{
TestMethod testMethod = new TestMethod(method, parentSuite);
testMethod.Seed = randomizer.Next();
string prefix = method.ReflectedType.FullName;
// Needed to give proper fullname to test in a parameterized fixture.
// Without this, the arguments to the fixture are not included.
if (parentSuite != null)
{
prefix = parentSuite.FullName;
//testMethod.FullName = prefix + "." + testMethod.Name;
}
if (CheckTestMethodSignature(testMethod, parms))
{
if (parms == null)
testMethod.ApplyAttributesToTest(method);
foreach (ICommandDecorator decorator in method.GetCustomAttributes(typeof(ICommandDecorator), true))
testMethod.CustomDecorators.Add(decorator);
ExpectedExceptionAttribute[] attributes =
(ExpectedExceptionAttribute[])method.GetCustomAttributes(typeof(ExpectedExceptionAttribute), false);
if (attributes.Length > 0)
{
ExpectedExceptionAttribute attr = attributes[0];
string handlerName = attr.Handler;
if (handlerName != null && GetExceptionHandler(testMethod.FixtureType, handlerName) == null)
MarkAsNotRunnable(
testMethod,
string.Format("The specified exception handler {0} was not found", handlerName));
testMethod.CustomDecorators.Add(new ExpectedExceptionDecorator(attr.ExceptionData));
}
}
if (parms != null)
{
// NOTE: After the call to CheckTestMethodSignature, the Method
// property of testMethod may no longer be the same as the
// original MethodInfo, so we reassign it here.
method = testMethod.Method;
if (parms.TestName != null)
{
testMethod.Name = parms.TestName;
testMethod.FullName = prefix + "." + parms.TestName;
}
else if (parms.OriginalArguments != null)
{
string name = MethodHelper.GetDisplayName(method, parms.OriginalArguments);
testMethod.Name = name;
testMethod.FullName = prefix + "." + name;
}
parms.ApplyToTest(testMethod);
}
return testMethod;
}
/// <summary>
/// Helper method that checks the signature of a TestMethod and
/// any supplied parameters to determine if the test is valid.
///
/// Currently, NUnitTestMethods are required to be public,
/// non-abstract methods, either static or instance,
/// returning void. They may take arguments but the values must
/// be provided or the TestMethod is not considered runnable.
///
/// Methods not meeting these criteria will be marked as
/// non-runnable and the method will return false in that case.
/// </summary>
/// <param name="testMethod">The TestMethod to be checked. If it
/// is found to be non-runnable, it will be modified.</param>
/// <param name="parms">Parameters to be used for this test, or null</param>
/// <returns>True if the method signature is valid, false if not</returns>
private static bool CheckTestMethodSignature(TestMethod testMethod, ParameterSet parms)
{
if (testMethod.Method.IsAbstract)
{
return MarkAsNotRunnable(testMethod, "Method is abstract");
}
if (!testMethod.Method.IsPublic)
{
return MarkAsNotRunnable(testMethod, "Method is not public");
}
#if NETCF
// TODO: Get this to work
if (testMethod.Method.IsGenericMethodDefinition)
{
return MarkAsNotRunnable(testMethod, "Generic test methods are not yet supported under .NET CF");
}
#endif
ParameterInfo[] parameters = testMethod.Method.GetParameters();
int argsNeeded = parameters.Length;
object[] arglist = null;
int argsProvided = 0;
if (parms != null)
{
testMethod.parms = parms;
testMethod.RunState = parms.RunState;
arglist = parms.Arguments;
if (arglist != null)
argsProvided = arglist.Length;
if (testMethod.RunState != RunState.Runnable)
return false;
}
Type returnType = testMethod.Method.ReturnType;
if (returnType.Equals(typeof(void)))
{
if (parms != null && parms.HasExpectedResult)
return MarkAsNotRunnable(testMethod, "Method returning void cannot have an expected result");
}
else
{
#if NET_4_5
if (MethodHelper.IsAsyncMethod(testMethod.Method))
{
bool returnsGenericTask = returnType.IsGenericType && returnType.GetGenericTypeDefinition() == typeof(Task<>);
if (returnsGenericTask && (parms == null|| !parms.HasExpectedResult && !parms.ExceptionExpected))
return MarkAsNotRunnable(testMethod, "Async test method must have Task or void return type when no result is expected");
else if (!returnsGenericTask && parms != null && parms.HasExpectedResult)
return MarkAsNotRunnable(testMethod, "Async test method must have Task<T> return type when a result is expected");
}
else
#endif
if (parms == null || !parms.HasExpectedResult && !parms.ExceptionExpected)
return MarkAsNotRunnable(testMethod, "Method has non-void return value, but no result is expected");
}
if (argsProvided > 0 && argsNeeded == 0)
{
return MarkAsNotRunnable(testMethod, "Arguments provided for method not taking any");
}
if (argsProvided == 0 && argsNeeded > 0)
{
return MarkAsNotRunnable(testMethod, "No arguments were provided");
}
if (argsProvided != argsNeeded)
{
return MarkAsNotRunnable(testMethod, "Wrong number of arguments provided");
}
#if CLR_2_0 || CLR_4_0
#if !NETCF
if (testMethod.Method.IsGenericMethodDefinition)
{
Type[] typeArguments = GetTypeArgumentsForMethod(testMethod.Method, arglist);
foreach (object o in typeArguments)
if (o == null)
{
return MarkAsNotRunnable(testMethod, "Unable to determine type arguments for method");
}
testMethod.method = testMethod.Method.MakeGenericMethod(typeArguments);
parameters = testMethod.Method.GetParameters();
}
#endif
#endif
if (arglist != null && parameters != null)
TypeHelper.ConvertArgumentList(arglist, parameters);
return true;
}
/// <summary>
/// Builds a ParameterizedMetodSuite containing individual
/// test cases for each set of parameters provided for
/// this method.
/// </summary>
/// <param name="method">The MethodInfo for which a test is to be built</param>
/// <param name="parentSuite">The test suite for which the method is being built</param>
/// <returns>A ParameterizedMethodSuite populated with test cases</returns>
public Test BuildParameterizedMethodSuite(MethodInfo method, Test parentSuite)
{
ParameterizedMethodSuite methodSuite = new ParameterizedMethodSuite(method);
methodSuite.ApplyAttributesToTest(method);
foreach (ITestCaseData testcase in testCaseProvider.GetTestCasesFor(method))
{
ParameterSet parms = testcase as ParameterSet;
if (parms == null)
parms = new ParameterSet(testcase);
TestMethod test = BuildSingleTestMethod(method, parentSuite, parms);
methodSuite.Add(test);
}
return methodSuite;
}
/// <summary>
/// Returns a set of ITestCaseDataItems for use as arguments
/// to a parameterized test method.
/// </summary>
/// <param name="method">The method for which data is needed.</param>
/// <returns></returns>
public IEnumerable<ITestCaseData> GetTestCasesFor(MethodInfo method)
{
List<ITestCaseData> data = new List<ITestCaseData>();
IEnumerable source = GetTestCaseSource(method);
if (source != null)
{
try
{
ParameterInfo[] parameters = method.GetParameters();
foreach (object item in source)
{
ParameterSet parms;
ITestCaseData testCaseData = item as ITestCaseData;
if (testCaseData != null)
parms = new ParameterSet(testCaseData);
else
{
object[] args = item as object[];
if (args != null)
{
if (args.Length != parameters.Length)
args = new object[] { item };
}
//else if (parameters.Length == 1 && parameters[0].ParameterType.IsAssignableFrom(item.GetType()))
//{
// args = new object[] { item };
//}
else if (item is Array)
{
Array array = item as Array;
if (array.Rank == 1 && array.Length == parameters.Length)
{
args = new object[array.Length];
for (int i = 0; i < array.Length; i++)
args[i] = (object)array.GetValue(i);
}
else
{
args = new object[] { item };
}
}
else
{
args = new object[] { item };
}
parms = new ParameterSet(args);
}
if (this.Category != null)
foreach (string cat in this.Category.Split(new char[] { ',' }))
parms.Properties.Add(PropertyNames.Category, cat);
data.Add(parms);
}
}
catch (Exception ex)
{
data.Clear();
data.Add(new ParameterSet(ex));
}
}
return data;
}
private static IEnumerable SourceMustBeStaticError()
{
var parms = new ParameterSet();
parms.RunState = RunState.NotRunnable;
parms.Properties.Set(PropertyNames.SkipReason, "The sourceName specified on a TestCaseSourceAttribute must refer to a static field, property or method.");
return new ParameterSet[] { parms };
}
/// <summary>
/// Returns a set of ITestCaseDataItems for use as arguments
/// to a parameterized test method.
/// </summary>
/// <param name="method">The method for which data is needed.</param>
/// <returns></returns>
public IEnumerable<ITestCaseData> GetTestCasesFor(MethodInfo method)
{
List<ITestCaseData> data = new List<ITestCaseData>();
try
{
IEnumerable source = GetTestCaseSource(method);
if (source != null)
{
#if NETCF
ParameterInfo[] parameters = method.IsGenericMethodDefinition ? new ParameterInfo[0] : method.GetParameters();
#else
ParameterInfo[] parameters = method.GetParameters();
#endif
foreach (object item in source)
{
ParameterSet parms;
ITestCaseData testCaseData = item as ITestCaseData;
if (testCaseData != null)
parms = new ParameterSet(testCaseData);
else
{
object[] args = item as object[];
if (args != null)
{
#if NETCF
if (method.IsGenericMethodDefinition)
{
var mi = method.MakeGenericMethodEx(args);
parameters = mi == null ? new ParameterInfo[0] : mi.GetParameters();
}
#endif
if (args.Length != parameters.Length)
args = new object[] { item };
}
// else if (parameters.Length == 1 && parameters[0].ParameterType.IsAssignableFrom(item.GetType()))
// {
// args = new object[] { item };
// }
else if (item is Array)
{
Array array = item as Array;
#if NETCF
if (array.Rank == 1 && (method.IsGenericMethodDefinition || array.Length == parameters.Length))
#else
if (array.Rank == 1 && array.Length == parameters.Length)
#endif
{
args = new object[array.Length];
for (int i = 0; i < array.Length; i++)
args[i] = array.GetValue(i);
#if NETCF
if (method.IsGenericMethodDefinition)
{
var mi = method.MakeGenericMethodEx(args);
if (mi == null || array.Length != mi.GetParameters().Length)
args = new object[] {item};
}
#endif
}
else
{
args = new object[] { item };
}
}
else
{
args = new object[] { item };
}
parms = new ParameterSet(args);
}
if (this.Category != null)
foreach (string cat in this.Category.Split(new char[] { ',' }))
parms.Properties.Add(PropertyNames.Category, cat);
data.Add(parms);
}
}
}
catch (Exception ex)
{
data.Clear();
data.Add(new ParameterSet(ex));
}
return data;
}
