/// <summary>
/// Resolves argument values for the test method, including support for optional method
/// arguments.
/// </summary>
/// <param name="testMethod">The test method to resolve.</param>
/// <param name="arguments">The user-supplied method arguments.</param>
/// <returns>The argument values</returns>
public static object?[] ResolveMethodArguments(
this MethodBase testMethod,
object?[] arguments)
{
Guard.ArgumentNotNull(testMethod);
var parameters = testMethod.GetParameters();
var hasParamsParameter = false;
// Params can only be added at the end of the parameter list
if (parameters.Length > 0)
{
hasParamsParameter = parameters[parameters.Length - 1].GetCustomAttribute(typeof(ParamArrayAttribute)) != null;
}
var nonOptionalParameterCount = parameters.Count(p => !p.IsOptional);
if (hasParamsParameter)
{
nonOptionalParameterCount--;
}
// We can't call a method if we provided fewer parameters than the number of non-optional parameters in the method.
if (arguments.Length < nonOptionalParameterCount)
{
return(arguments);
}
// We can't call a non-params method if we have provided more parameters than the total number of parameters in the method.
if (!hasParamsParameter && arguments.Length > parameters.Length)
{
return(arguments);
}
var newArguments = new object?[parameters.Length];
var resolvedArgumentsCount = 0;
if (hasParamsParameter)
{
var paramsParameter = parameters[parameters.Length - 1];
var paramsElementType = paramsParameter.ParameterType.GetElementType();
if (paramsElementType == null)
{
throw new InvalidOperationException("Cannot determine params element type");
}
if (arguments.Length < parameters.Length)
{
// Didn't include the params parameter
var emptyParamsArray = Array.CreateInstance(paramsElementType, 0);
newArguments[newArguments.Length - 1] = emptyParamsArray;
}
else if (arguments.Length == parameters.Length &&
(arguments[arguments.Length - 1] == null ||
(arguments[arguments.Length - 1] !.GetType().IsArray&&
arguments[arguments.Length - 1] !.GetType().GetElementType() == paramsElementType)))
{
// Passing null or the same type array as the params parameter
newArguments[newArguments.Length - 1] = arguments[arguments.Length - 1];
resolvedArgumentsCount = 1;
}
else
{
// Parameters need adjusting into an array
var paramsArrayLength = arguments.Length - parameters.Length + 1;
var paramsArray = Array.CreateInstance(paramsElementType, paramsArrayLength);
try
{
Array.Copy(arguments, parameters.Length - 1, paramsArray, 0, paramsArray.Length);
}
catch (ArrayTypeMismatchException)
{
throw new InvalidOperationException($"The arguments for this test method did not match the parameters: {ArgumentFormatter.Format(arguments)}");
}
catch (InvalidCastException)
{
throw new InvalidOperationException($"The arguments for this test method did not match the parameters: {ArgumentFormatter.Format(arguments)}");
}
newArguments[newArguments.Length - 1] = paramsArray;
resolvedArgumentsCount = paramsArrayLength;
}
}
static string ParameterToDisplayValue(string parameterName, object parameterValue)
=> $"{parameterName}: {ArgumentFormatter.Format(parameterValue)}";
static string ParameterToDisplayValue(string parameterName, object parameterValue)
{
return(String.Format("{0}: {1}", parameterName, ArgumentFormatter.Format(parameterValue)));
}
/// <summary>
/// Creates a new instance of the <see cref="ThrowsException"/> class. Call this constructor
/// when an exception of the wrong type was thrown.
/// </summary>
/// <param name="expectedType">The type of the exception that was expected</param>
/// <param name="actual">The actual exception that was thrown</param>
public ThrowsException(Type expectedType, Exception actual)
: this(expectedType, ArgumentFormatter.Format(actual.GetType()), actual.Message, actual.StackTrace)
{
}
public EmptyException(IEnumerable collection)
: base("<empty>", ArgumentFormatter.Format(collection), "Assert.Empty() Failure")
{
}
/// <summary>
/// Resolves argument values for the test method, including support for optional method
/// arguments.
/// </summary>
/// <param name="testMethod">The test method to resolve.</param>
/// <param name="arguments">The user-supplied method arguments.</param>
/// <returns>The argument values</returns>
public static object[] ResolveMethodArguments(this MethodBase testMethod, object[] arguments)
{
var parameters = testMethod.GetParameters();
bool hasParamsParameter = false;
// Params can only be added at the end of the parameter list
if (parameters.Length > 0)
{
hasParamsParameter = parameters[parameters.Length - 1].GetCustomAttribute(typeof(ParamArrayAttribute)) != null;
}
var nonOptionalParameterCount = parameters.Count(p => !p.IsOptional);
if (hasParamsParameter)
{
nonOptionalParameterCount--;
}
// We can't call a method if we provided fewer parameters than the number of non-optional parameters in the method.
if (arguments.Length < nonOptionalParameterCount)
{
return(arguments);
}
// We can't call a non-params method if we have provided more parameters than the total number of parameters in the method.
if (!hasParamsParameter && arguments.Length > parameters.Length)
{
return(arguments);
}
var newArguments = new object[parameters.Length];
var resolvedArgumentsCount = 0;
if (hasParamsParameter)
{
var paramsParameter = parameters[parameters.Length - 1];
var paramsElementType = paramsParameter.ParameterType.GetElementType();
if (arguments.Length < parameters.Length)
{
// Didn't include the params parameter
var emptyParamsArray = Array.CreateInstance(paramsElementType, 0);
newArguments[newArguments.Length - 1] = emptyParamsArray;
}
else if (arguments.Length == parameters.Length &&
(arguments[arguments.Length - 1] == null ||
(arguments[arguments.Length - 1].GetType().IsArray&&
arguments[arguments.Length - 1].GetType().GetElementType() == paramsElementType)))
{
// Passing null or the same type array as the params parameter
newArguments[newArguments.Length - 1] = arguments[arguments.Length - 1];
resolvedArgumentsCount = 1;
}
else
{
// Parameters need adjusting into an array
var paramsArrayLength = arguments.Length - parameters.Length + 1;
var paramsArray = Array.CreateInstance(paramsElementType, paramsArrayLength);
try
{
Array.Copy(arguments, parameters.Length - 1, paramsArray, 0, paramsArray.Length);
}
catch (InvalidCastException)
{
throw new InvalidOperationException($"The arguments for this test method did not match the parameters: {ArgumentFormatter.Format(arguments)}");
}
newArguments[newArguments.Length - 1] = paramsArray;
resolvedArgumentsCount = paramsArrayLength;
}
}
// If the argument has been provided, pass the argument value
for (var i = 0; i < arguments.Length - resolvedArgumentsCount; i++)
{
newArguments[i] = TryConvertObject(arguments[i], parameters[i].ParameterType);
}
// If the argument has not been provided, pass the default value
int unresolvedParametersCount = hasParamsParameter ? parameters.Length - 1 : parameters.Length;
for (var i = arguments.Length; i < unresolvedParametersCount; i++)
{
var parameter = parameters[i];
if (parameter.HasDefaultValue)
{
newArguments[i] = parameter.DefaultValue;
}
else
{
newArguments[i] = parameter.ParameterType.GetTypeInfo().GetDefaultValue();
}
}
return(newArguments);
}
public ThrowsException(Type expectedType, Exception actual)
#if XUNIT_NULLABLE
: this(expectedType, ArgumentFormatter.Format(actual.GetType()) !, actual.Message, actual.StackTrace, actual)
