/// <summary>
/// Retrieves a list of arguments which can be passed to the specified parameter.
/// </summary>
/// <param name="fixtureType">The point of context in the fixture’s inheritance hierarchy.</param>
/// <param name="parameter">The parameter of a parameterized test.</param>
public IEnumerable GetData(Type fixtureType, ParameterInfo parameter)
{
var from = ParamAttributeTypeConversions.Convert(_from, parameter.ParameterType);
var to = ParamAttributeTypeConversions.Convert(_to, parameter.ParameterType);
var valueGenerator = ValueGenerator.Create(parameter.ParameterType);
ValueGenerator.Step step;
if (!valueGenerator.TryCreateStep(_step, out step))
{
// ValueGenerator.CreateStep has the responsibility to enable Byte values to be incremented
// by the Int32 value -1. Or perhaps in the future, DateTime values to be incremented by a TimeSpan.
// It handles scenarios where the incrementing type is fundamentally different in its most natural form.
// However, ParamAttributeTypeConversions has the responsibility to convert attribute arguments
// that are only of a different type due to IL limitations or NUnit smoothing over overload differences.
// See the XML docs for the ParamAttributeTypeConversions class.
object stepValueToRequire;
if (!ParamAttributeTypeConversions.TryConvert(_step, parameter.ParameterType, out stepValueToRequire))
{
// This will cause CreateStep to throw the same exception as it would throw if TryConvert
// succeeded but the value generator still didn’t recognize the step value.
stepValueToRequire = _step;
}
step = valueGenerator.CreateStep(stepValueToRequire);
}
return(valueGenerator.GenerateRange(from, to, step));
}
/// <summary>
/// Retrieves a list of arguments which can be passed to the specified parameter.
/// </summary>
/// <param name="fixtureType">The point of context in the fixture’s inheritance hierarchy.</param>
/// <param name="parameter">The parameter of a parameterized test.</param>
public IEnumerable GetData(Type fixtureType, ParameterInfo parameter)
{
if (data.Length == 0)
{
return(GenerateData(parameter.ParameterType));
}
else
{
return(ParamAttributeTypeConversions.ConvertData(data, parameter.ParameterType));
}
}
private static void PerformSpecialConversions(object?[] arglist, IParameterInfo[] parameters)
{
for (int i = 0; i < arglist.Length; i++)
{
object?arg = arglist[i];
Type targetType = parameters[i].ParameterType;
if (ParamAttributeTypeConversions.TryConvert(arg, targetType, out var argAsTargetType))
{
arglist[i] = argAsTargetType;
}
}
}
private TestCaseParameters GetParametersForTestCase(IMethodInfo method)
{
TestCaseParameters parms;
try
{
IParameterInfo[] parameters = method.GetParameters();
int argsNeeded = parameters.Length;
int argsProvided = Arguments.Length;
parms = new TestCaseParameters(this);
// Special handling for ExpectedResult (see if it needs to be converted into method return type)
if (parms.HasExpectedResult &&
ParamAttributeTypeConversions.TryConvert(parms.ExpectedResult, method.ReturnType.Type, out var expectedResultInTargetType))
{
parms.ExpectedResult = expectedResultInTargetType;
}
// Special handling for params arguments
if (argsNeeded > 0 && argsProvided >= argsNeeded - 1)
{
IParameterInfo lastParameter = parameters[argsNeeded - 1];
Type lastParameterType = lastParameter.ParameterType;
Type elementType = lastParameterType.GetElementType();
if (lastParameterType.IsArray && lastParameter.IsDefined <ParamArrayAttribute>(false))
{
if (argsProvided == argsNeeded)
{
if (!lastParameterType.IsInstanceOfType(parms.Arguments[argsProvided - 1]))
{
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;
}
}
}
//Special handling for optional parameters
if (parms.Arguments.Length < argsNeeded)
{
object?[] newArgList = new object?[parameters.Length];
Array.Copy(parms.Arguments, newArgList, parms.Arguments.Length);
//Fill with Type.Missing for remaining required parameters where optional
for (var i = parms.Arguments.Length; i < parameters.Length; i++)
{
if (parameters[i].IsOptional)
{
newArgList[i] = Type.Missing;
}
else
{
if (i < parms.Arguments.Length)
{
newArgList[i] = parms.Arguments[i];
}
else
{
throw new TargetParameterCountException(string.Format(
"Method requires {0} arguments but TestCaseAttribute only supplied {1}",
argsNeeded,
argsProvided));
}
}
}
parms.Arguments = newArgList;
}
// 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 TestCaseParameters(ex);
}
return(parms);
}
/// <summary>
/// Retrieves a list of arguments which can be passed to the specified parameter.
/// </summary>
/// <param name="fixtureType">The point of context in the fixture’s inheritance hierarchy.</param>
/// <param name="parameter">The parameter of a parameterized test.</param>
public IEnumerable GetData(Type fixtureType, ParameterInfo parameter)
{
return(ParamAttributeTypeConversions.ConvertData(data, parameter.ParameterType));
}
