/// <summary>
/// Construct a ParameterSet from an object implementing ITestCaseData
/// </summary>
/// <param name="data"></param>
public TestCaseParameters(ITestCaseData data) : base(data)
{
if (data.HasExpectedResult)
{
ExpectedResult = data.ExpectedResult;
}
}
public IEnumerable <ITestCaseData> GetTestCasesFor(MethodInfo method)
{
List <ITestCaseData> list = new List <ITestCaseData>();
IEnumerable testCaseSource = GetTestCaseSource(method);
if (testCaseSource != null)
{
ParameterInfo[] parameters = method.GetParameters();
foreach (object item in testCaseSource)
{
ParameterSet parameterSet = new ParameterSet();
ITestCaseData testCaseData = item as ITestCaseData;
if (testCaseData != null)
{
parameterSet = new ParameterSet(testCaseData);
}
else if (item is object[])
{
object[] array = item as object[];
parameterSet.Arguments = ((array.Length == parameters.Length) ? array : new object[1] {
item
});
}
else if (item is Array)
{
Array array2 = item as Array;
if (array2.Rank == 1 && array2.Length == parameters.Length)
{
parameterSet.Arguments = new object[array2.Length];
for (int i = 0; i < array2.Length; i++)
{
parameterSet.Arguments[i] = array2.GetValue(i);
}
}
else
{
parameterSet.Arguments = new object[1] {
item
};
}
}
else
{
parameterSet.Arguments = new object[1] {
item
};
}
if (Category != null)
{
string[] array3 = Category.Split(',');
foreach (string value in array3)
{
parameterSet.Properties.Add(PropertyNames.Category, value);
}
}
list.Add(parameterSet);
}
}
return(list);
}
/// <summary>
/// Construct a ParameterSet from an object implementing ITestCaseData
/// </summary>
/// <param name="data"></param>
public ParameterSet(ITestCaseData data)
{
this.TestName = data.TestName;
this.RunState = data.RunState;
this.Arguments = this.OriginalArguments = data.Arguments;
if (data.HasExpectedResult)
ExpectedResult = data.ExpectedResult;
this.Properties = new PropertyBag();
foreach (string key in data.Properties.Keys)
this.Properties[key] = data.Properties[key];
}
/// <summary>
/// Construct a ParameterSet from an object implementing ITestCaseData
/// </summary>
/// <param name="data"></param>
public ParameterSet(ITestCaseData data)
{
this.TestName = data.TestName;
this.RunState = data.RunState;
this.Arguments = data.Arguments;
this.exceptionData = data.ExceptionData;
if (data.HasExpectedResult)
this.ExpectedResult = data.ExpectedResult;
foreach (string key in data.Properties.Keys)
this.Properties[key] = data.Properties[key];
}
public ParameterSet(ITestCaseData data)
{
TestName = data.TestName;
RunState = data.RunState;
Arguments = data.Arguments;
exceptionData = data.ExceptionData;
if (data.HasExpectedResult)
{
ExpectedResult = data.ExpectedResult;
}
foreach (string key in data.Properties.Keys)
{
Properties[key] = data.Properties[key];
}
}
/// <summary>
/// Construct a ParameterSet from an object implementing ITestCaseData
/// </summary>
/// <param name="data"></param>
public ParameterSet(ITestCaseData data)
{
this.TestName = data.TestName;
this.RunState = data.RunState;
this.Arguments = this.OriginalArguments = data.Arguments;
if (data.HasExpectedResult)
{
ExpectedResult = data.ExpectedResult;
}
this.Properties = new PropertyBag();
foreach (string key in data.Properties.Keys)
{
this.Properties[key] = data.Properties[key];
}
}
/// <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>
private IEnumerable <ITestCaseData> GetTestCasesFor(IMethodInfo method)
{
List <ITestCaseData> data = new List <ITestCaseData>();
try
{
IEnumerable source = GetTestCaseSource(method);
if (source != null)
{
foreach (object item in source)
{
// First handle two easy cases:
// 1. Source is null. This is really an error but if we
// throw an exception we simply get an invalid fixture
// without good info as to what caused it. Passing a
// single null argument will cause an error to be
// reported at the test level, in most cases.
// 2. User provided an ITestCaseData and we just use it.
ITestCaseData parms = item == null
? new TestCaseParameters(new object[] { null })
: item as ITestCaseData;
if (parms == null)
{
object[] args = null;
// 3. An array was passed, it may be an object[]
// or possibly some other kind of array, which
// TestCaseSource can accept.
var array = item as Array;
if (array != null)
{
// If array has the same number of elements as parameters
// and it does not fit exactly into single existing parameter
// we believe that this array contains arguments, not is a bare
// argument itself.
var parameters = method.GetParameters();
var argsNeeded = parameters.Length;
if (argsNeeded > 0 && argsNeeded == array.Length && parameters[0].ParameterType != array.GetType())
{
args = new object[array.Length];
for (var i = 0; i < array.Length; i++)
{
args[i] = array.GetValue(i);
}
}
}
if (args == null)
{
args = new object[] { item };
}
parms = new TestCaseParameters(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 TestCaseParameters(ex));
}
return(data);
}
/// <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>
private IEnumerable <ITestCaseData> GetTestCasesFor(IMethodInfo method)
{
List <ITestCaseData> data = new List <ITestCaseData>();
try
{
IEnumerable source = GetTestCaseSource(method);
if (source != null)
{
foreach (object item in source)
{
// First handle two easy cases:
// 1. Source is null. This is really an error but if we
// throw an exception we simply get an invalid fixture
// without good info as to what caused it. Passing a
// single null argument will cause an error to be
// reported at the test level, in most cases.
// 2. User provided an ITestCaseData and we just use it.
ITestCaseData parms = item == null
? new TestCaseParameters(new object[] { null })
: item as ITestCaseData;
if (parms == null)
{
// 3. An array was passed, it may be an object[]
// or possibly some other kind of array, which
// TestCaseSource can accept.
var args = item as object[];
if (args == null && item is Array)
{
Array array = item as Array;
#if NETCF
bool netcfOpenType = method.IsGenericMethodDefinition;
#else
bool netcfOpenType = false;
#endif
int numParameters = netcfOpenType ? array.Length : method.GetParameters().Length;
if (array != null && array.Rank == 1 && array.Length == numParameters)
{
// Array is something like int[] - convert it to
// an object[] for use as the argument array.
args = new object[array.Length];
for (int i = 0; i < array.Length; i++)
{
args[i] = array.GetValue(i);
}
}
}
// Check again if we have an object[]
if (args != null)
{
#if NETCF
if (method.IsGenericMethodDefinition)
{
var mi = method.MakeGenericMethodEx(args);
if (mi == null)
{
throw new NotSupportedException("Cannot determine generic Type");
}
method = mi;
}
#endif
var parameters = method.GetParameters();
var argsNeeded = parameters.Length;
var argsProvided = args.Length;
// If only one argument is needed, our array may actually
// be the bare argument. If it is, we should wrap it in
// an outer object[] representing the list of arguments.
if (argsNeeded == 1)
{
var singleParmType = parameters[0].ParameterType;
if (argsProvided == 0 || typeof(object[]).IsAssignableFrom(singleParmType))
{
if (argsProvided > 1 || singleParmType.IsAssignableFrom(args.GetType()))
{
args = new object[] { item };
}
}
}
}
else // It may be a scalar or a multi-dimensioned array. Wrap it in object[]
{
args = new object[] { item };
}
parms = new TestCaseParameters(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 TestCaseParameters(ex));
}
return(data);
}
/// <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)
{
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>
/// 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
{
#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);
}
/// <summary>
/// Construct a ParameterSet from an object implementing ITestCaseData
/// </summary>
/// <param name="data"></param>
public TestCaseParameters(ITestCaseData data) : base(data)
{
if (data.HasExpectedResult)
ExpectedResult = data.ExpectedResult;
}
