private static string GetGenericArgumentsIfNecessary(IMethodInfo method, TranslationContext context)
{
if (!method.IsGenericMethod)
{
return(null);
}
var methodGenericDefinition = method.GetGenericMethodDefinition();
var genericParameterTypes = methodGenericDefinition.GetGenericArguments().ToList();
if (context.Settings.UseImplicitGenericParameters)
{
RemoveSuppliedGenericTypeParameters(
methodGenericDefinition.GetParameters().Project(p => p.ParameterType),
genericParameterTypes);
}
if (!genericParameterTypes.Any())
{
return(null);
}
var argumentNames = method
.GetGenericArguments()
.Project(a => a.GetFriendlyName())
.Filter(name => name != null)
.ToArray();
return(argumentNames.Any() ? $"<{string.Join(", ", argumentNames)}>" : null);
}
public ScenarioInfo(IMethodInfo testMethod, object[] dataRow, string scenarioOutlineDisplayName)
{
var parameters = testMethod.GetParameters().ToList();
var typeParameters = testMethod.GetGenericArguments().ToList();
ITypeInfo[] typeArguments;
if (testMethod.IsGenericMethodDefinition)
{
typeArguments = typeParameters
.Select(typeParameter => InferTypeArgument(typeParameter.Name, parameters, dataRow))
.ToArray();
this.MethodToRun = testMethod.MakeGenericMethod(typeArguments).ToRuntimeMethod();
}
else
{
typeArguments = new ITypeInfo[0];
this.MethodToRun = testMethod.ToRuntimeMethod();
}
var passedArguments = Reflector.ConvertArguments(
dataRow, this.MethodToRun.GetParameters().Select(p => p.ParameterType).ToArray());
var generatedArguments = GetGeneratedArguments(
typeParameters, typeArguments, parameters, passedArguments.Length);
var arguments = passedArguments
.Select(value => new Argument(value))
.Concat(generatedArguments)
.ToList();
this.ScenarioDisplayName = GetScenarioDisplayName(scenarioOutlineDisplayName, typeArguments, parameters, arguments);
this.ConvertedDataRow = arguments.Select(argument => argument.Value).ToList();
}
public Type[] GetGenericArgumentsFor(IMethodInfo genericMethod)
{
var types = new List <Type>();
foreach (var genType in genericMethod.GetGenericArguments())
{
types.Add(name2GenericType[genType.Name].AsType());
}
return(types.ToArray());
}
/// <summary>
/// Resolves all the generic types for a test method. The test parameters are used to determine
/// the best matching generic types for the test method that can be satisfied by all
/// the generic parameters and their values.
/// </summary>
/// <param name="method">The test method</param>
/// <param name="parameters">The parameter values being passed to the test method</param>
/// <returns>The best matching generic types</returns>
public static ITypeInfo[] ResolveGenericTypes(this IMethodInfo method, object[] parameters)
{
var genericTypes = method.GetGenericArguments().ToArray();
var resolvedTypes = new ITypeInfo[genericTypes.Length];
var parameterInfos = method.GetParameters().CastOrToArray();
for (var idx = 0; idx < genericTypes.Length; ++idx)
{
resolvedTypes[idx] = ResolveGenericType(genericTypes[idx], parameters, parameterInfos);
}
return(resolvedTypes);
}
/// <summary>
/// FOR INTERNAL USE ONLY.
/// </summary>
protected static ITypeInfo[] ResolveGenericTypes(IMethodInfo method, object[] parameters)
{
ITypeInfo[] genericTypes = method.GetGenericArguments().ToArray();
ITypeInfo[] resolvedTypes = new ITypeInfo[genericTypes.Length];
IParameterInfo[] parameterInfos = method.GetParameters().ToArray();
for (int idx = 0; idx < genericTypes.Length; ++idx)
{
resolvedTypes[idx] = ResolveGenericType(genericTypes[idx], parameters, parameterInfos);
}
return(resolvedTypes);
}
private static ITypeInfo GetTypeFromGenericArgumentReferenceType(IMetadataGenericArgumentReferenceType reference, ITypeInfo typeInfo, IMethodInfo methodInfo)
{
var argument = reference.Argument;
switch (argument.Kind)
{
case GenericArgumentKind.Type:
return typeInfo.GetGenericArguments().ToList()[(int)argument.Index];
case GenericArgumentKind.Method:
return methodInfo.GetGenericArguments().ToList()[(int)argument.Index];
}
return null;
}
private static ITypeInfo GetTypeFromGenericArgumentReferenceType(IMetadataGenericArgumentReferenceType reference, ITypeInfo typeInfo, IMethodInfo methodInfo)
{
var argument = reference.Argument;
switch (argument.Kind)
{
case GenericArgumentKind.Type:
return(typeInfo.GetGenericArguments().ToList()[(int)argument.Index]);
case GenericArgumentKind.Method:
return(methodInfo.GetGenericArguments().ToList()[(int)argument.Index]);
}
return(null);
}
IEnumerable <TestMethod> ITestBuilder.BuildFrom(IMethodInfo method, Test suite)
{
if (!method.IsGenericMethodDefinition)
{
return(base.BuildFrom(method, suite));
}
if (TypeArguments == null || TypeArguments.Length != method.GetGenericArguments().Length)
{
var parms = new TestCaseParameters {
RunState = RunState.NotRunnable
};
parms.Properties.Set("_SKIPREASON", $"{nameof(TypeArguments)} should have {method.GetGenericArguments().Length} elements");
return(new[] { new NUnitTestCaseBuilder().BuildTestMethod(method, suite, parms) });
}
var genMethod = method.MakeGenericMethod(TypeArguments);
return(base.BuildFrom(genMethod, suite));
}
private static IMethodInfo ObtainMethod(IMethodInfo proxiedMethod, Type type)
{
Type[] genericArguments = null;
if (proxiedMethod.IsGenericMethod)
{
genericArguments = proxiedMethod.GetGenericArguments();
proxiedMethod = proxiedMethod.GetGenericMethodDefinition();
}
var declaringType = proxiedMethod.DeclaringType;
IMethodInfo methodOnTarget = null;
if (declaringType.IsInterface())
{
var mapping = type.GetInterfaceMap(declaringType);
var index = Array.IndexOf(mapping.InterfaceMethods, proxiedMethod);
Debug.Assert(index != -1);
methodOnTarget = mapping.TargetMethods[index].AsIMethodInfo();
}
else
{
// NOTE: this implementation sucks, feel free to improve it.
var methods = MethodFinder.GetAllInstanceMethods(type, BindingFlags.Public | BindingFlags.NonPublic);
foreach (var method in methods)
{
if (MethodSignatureComparer.Instance.Equals(method.GetBaseDefinition(), proxiedMethod))
{
methodOnTarget = method;
break;
}
}
}
if (methodOnTarget == null)
{
throw new ArgumentException(
string.Format("Could not find method overriding {0} on type {1}. This is most likely a bug. Please report it.",
proxiedMethod, type));
}
if (genericArguments == null)
{
return(methodOnTarget);
}
return(methodOnTarget.MakeGenericMethod(genericArguments));
}
private void EmitLoadGenricMethodArguments(MethodEmitter methodEmitter, IMethodInfo method, Reference invocationLocal)
{
var genericParameters = new List <Type>(method.GetGenericArguments()).FindAll(t => t.IsGenericParameter);
var genericParamsArrayLocal = methodEmitter.CodeBuilder.DeclareLocal(typeof(Type[]));
methodEmitter.CodeBuilder.AddStatement(
new AssignStatement(genericParamsArrayLocal, new NewArrayExpression(genericParameters.Count, typeof(Type))));
for (var i = 0; i < genericParameters.Count; ++i)
{
methodEmitter.CodeBuilder.AddStatement(
new AssignArrayStatement(genericParamsArrayLocal, i, new TypeTokenExpression(genericParameters[i])));
}
methodEmitter.CodeBuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(invocationLocal,
InvocationMethods.SetGenericMethodArguments,
new ReferenceExpression(
genericParamsArrayLocal))));
}
private static IMethodInfo ObtainMethod(IMethodInfo proxiedMethod, Type type)
{
Type[] genericArguments = null;
if (proxiedMethod.IsGenericMethod)
{
genericArguments = proxiedMethod.GetGenericArguments();
proxiedMethod = proxiedMethod.GetGenericMethodDefinition();
}
var declaringType = proxiedMethod.DeclaringType;
IMethodInfo methodOnTarget = null;
if (declaringType.IsInterface())
{
var mapping = type.GetInterfaceMap(declaringType);
var index = Array.IndexOf(mapping.InterfaceMethods, proxiedMethod);
Debug.Assert(index != -1);
methodOnTarget = mapping.TargetMethods[index].AsIMethodInfo();
}
else
{
// NOTE: this implementation sucks, feel free to improve it.
var methods = MethodFinder.GetAllInstanceMethods(type, BindingFlags.Public | BindingFlags.NonPublic);
foreach (var method in methods)
{
if (MethodSignatureComparer.Instance.Equals(method.GetBaseDefinition(), proxiedMethod))
{
methodOnTarget = method;
break;
}
}
}
if (methodOnTarget == null)
{
throw new ArgumentException(
string.Format("Could not find method overriding {0} on type {1}. This is most likely a bug. Please report it.",
proxiedMethod, type));
}
if (genericArguments == null)
{
return methodOnTarget;
}
return methodOnTarget.MakeGenericMethod(genericArguments);
}
public ScenarioInfo(IMethodInfo testMethod, object[] actualArgs, string scenarioOutlineDisplayName)
{
//Guard.AgainstNullArgument(nameof(testMethod), testMethod);
#if DEBUG
testMethod = testMethod.RequiresNotNull(nameof(testMethod));
#endif
// Which, we "do", in DEBUG mode.
#pragma warning disable CA1062 // ...validate parameter 'name' is non-null before using it...
var parameters = testMethod.GetParameters().ToList();
#pragma warning restore CA1062 // ...validate parameter 'name' is non-null before using it...
var typeParams = testMethod.GetGenericArguments().ToList();
ITypeInfo[] typeArgs;
if (testMethod.IsGenericMethodDefinition)
{
typeArgs = typeParams
.Select(typeParameter => InferTypeArgument(typeParameter.Name, parameters, actualArgs))
.ToArray();
this.MethodToRun = testMethod.MakeGenericMethod(typeArgs).ToRuntimeMethod();
}
else
{
typeArgs = Array.Empty <ITypeInfo>();
this.MethodToRun = testMethod.ToRuntimeMethod();
}
var passedArgs = Reflector.ConvertArguments(actualArgs, this.MethodToRun.GetParameters().Select(p => p.ParameterType).ToArray());
var generatedArguments = GetGeneratedArguments(typeParams, typeArgs, parameters, passedArgs.Length);
var args = passedArgs
.Select(value => new Argument(value))
.Concat(generatedArguments)
.ToList();
this.ScenarioDisplayName = GetScenarioDisplayName(scenarioOutlineDisplayName, typeArgs, parameters, args);
this.ConvertedActualArgs = args.Select(arg => arg.Value).ToList();
}
IEnumerable <TestMethod> ITestBuilder.BuildFrom(IMethodInfo method, Test suite)
{
if (!method.IsGenericMethodDefinition)
{
return(base.BuildFrom(method, suite));
}
var numberOfGenericArguments = method.GetGenericArguments().Length;
var typeArguments = Arguments.Take(numberOfGenericArguments).OfType <Type>().ToArray();
if (typeArguments.Length != numberOfGenericArguments)
{
var parms = new TestCaseParameters {
RunState = RunState.NotRunnable
};
parms.Properties.Set("_SKIPREASON", $"Arguments should have {typeArguments} type elements");
return(new[] { new NUnitTestCaseBuilder().BuildTestMethod(method, suite, parms) });
}
var genMethod = method.MakeGenericMethod(typeArguments);
return(new TestCaseAttribute(Arguments.Skip(numberOfGenericArguments).ToArray()).BuildFrom(genMethod, suite));
}
private static GenericTypeParameterBuilder[] CopyGenericArguments(
IMethodInfo methodToCopyGenericsFrom,
Dictionary <String, GenericTypeParameterBuilder> name2GenericType,
ApplyGenArgs genericParameterGenerator)
{
var originalGenericArguments = methodToCopyGenericsFrom.GetGenericArguments();
if (originalGenericArguments.Length == 0)
{
return(null);
}
var argumentNames = GetArgumentNames(originalGenericArguments);
var newGenericParameters = genericParameterGenerator(argumentNames);
for (var i = 0; i < newGenericParameters.Length; i++)
{
try
{
var attributes = originalGenericArguments[i].GenericParameterAttributes();
newGenericParameters[i].SetGenericParameterAttributes(attributes);
var constraints = AdjustGenericConstraints(methodToCopyGenericsFrom, newGenericParameters, originalGenericArguments, originalGenericArguments[i].GetGenericParameterConstraints());
newGenericParameters[i].SetInterfaceConstraints(constraints);
CopyNonInheritableAttributes(newGenericParameters[i], originalGenericArguments[i]);
}
catch (NotSupportedException)
{
// Doesnt matter
newGenericParameters[i].SetGenericParameterAttributes(GenericParameterAttributes.None);
}
name2GenericType[argumentNames[i]] = newGenericParameters[i];
}
return(newGenericParameters);
}
/// <summary>
/// Construct one or more TestMethods from a given MethodInfo,
/// using available parameter data.
/// </summary>
/// <param name="method">The MethodInfo for which tests are to be constructed.</param>
/// <param name="suite">The suite to which the tests will be added.</param>
/// <returns>One or more TestMethods</returns>
public IEnumerable<TestMethod> BuildFrom(IMethodInfo method, Test suite)
{
List<TestMethod> tests = new List<TestMethod>();
#if NETCF
if (method.ContainsGenericParameters)
{
var genericParams = method.GetGenericArguments();
var numGenericParams = genericParams.Length;
var o = new object();
var tryArgs = Enumerable.Repeat(o, numGenericParams).ToArray();
IMethodInfo mi;
try
{
// This fails if the generic method has constraints
// that are not met by object.
mi = method.MakeGenericMethodEx(tryArgs);
if (mi == null)
return tests;
}
catch
{
return tests;
}
var par = mi.GetParameters();
if (par.Length == 0)
return tests;
var sourceData = par.Select(p => _dataProvider.GetDataFor(p)).ToArray();
foreach (var parms in _strategy.GetTestCases(sourceData))
{
mi = method.MakeGenericMethodEx(parms.Arguments);
if (mi == null)
{
var tm = new TestMethod(method, suite);
tm.RunState = RunState.NotRunnable;
tm.Properties.Set(PropertyNames.SkipReason, "Incompatible arguments");
tests.Add(tm);
}
else
tests.Add(_builder.BuildTestMethod(mi, suite, (TestCaseParameters)parms));
}
return tests;
}
#endif
IParameterInfo[] parameters = method.GetParameters();
if (parameters.Length > 0)
{
IEnumerable[] sources = new IEnumerable[parameters.Length];
try
{
for (int i = 0; i < parameters.Length; i++)
sources[i] = _dataProvider.GetDataFor(parameters[i]);
}
catch (InvalidDataSourceException ex)
{
var parms = new TestCaseParameters();
parms.RunState = RunState.NotRunnable;
parms.Properties.Set(PropertyNames.SkipReason, ex.Message);
tests.Add(_builder.BuildTestMethod(method, suite, parms));
return tests;
}
foreach (var parms in _strategy.GetTestCases(sources))
tests.Add(_builder.BuildTestMethod(method, suite, (TestCaseParameters)parms));
}
return tests;
}
public IEnumerable <ITypeInfo> GetGenericArguments()
{
return(_inner.GetGenericArguments());
}
public Type[] GetGenericArguments()
{
return(_baseInfo.GetGenericArguments());
}
/// <summary>
/// Construct one or more TestMethods from a given MethodInfo,
/// using available parameter data.
/// </summary>
/// <param name="method">The MethodInfo for which tests are to be constructed.</param>
/// <param name="suite">The suite to which the tests will be added.</param>
/// <returns>One or more TestMethods</returns>
public IEnumerable <TestMethod> BuildFrom(IMethodInfo method, Test suite)
{
List <TestMethod> tests = new List <TestMethod>();
#if NETCF
if (method.ContainsGenericParameters)
{
var genericParams = method.GetGenericArguments();
var numGenericParams = genericParams.Length;
var o = new object();
var tryArgs = Enumerable.Repeat(o, numGenericParams).ToArray();
IMethodInfo mi;
try
{
// This fails if the generic method has constraints
// that are not met by object.
mi = method.MakeGenericMethodEx(tryArgs);
if (mi == null)
{
return(tests);
}
}
catch
{
return(tests);
}
var par = mi.GetParameters();
if (par.Length == 0)
{
return(tests);
}
var sourceData = par.Select(p => _dataProvider.GetDataFor(p)).ToArray();
foreach (var parms in _strategy.GetTestCases(sourceData))
{
mi = method.MakeGenericMethodEx(parms.Arguments);
if (mi == null)
{
var tm = new TestMethod(method, suite);
tm.RunState = RunState.NotRunnable;
tm.Properties.Set(PropertyNames.SkipReason, "Incompatible arguments");
tests.Add(tm);
}
else
{
tests.Add(_builder.BuildTestMethod(mi, suite, (TestCaseParameters)parms));
}
}
return(tests);
}
#endif
IParameterInfo[] parameters = method.GetParameters();
if (parameters.Length > 0)
{
IEnumerable[] sources = new IEnumerable[parameters.Length];
try
{
for (int i = 0; i < parameters.Length; i++)
{
sources[i] = _dataProvider.GetDataFor(parameters[i]);
}
}
catch (InvalidDataSourceException ex)
{
var parms = new TestCaseParameters();
parms.RunState = RunState.NotRunnable;
parms.Properties.Set(PropertyNames.SkipReason, ex.Message);
tests.Add(_builder.BuildTestMethod(method, suite, parms));
return(tests);
}
foreach (var parms in _strategy.GetTestCases(sources))
{
tests.Add(_builder.BuildTestMethod(method, suite, (TestCaseParameters)parms));
}
}
return(tests);
}
/// <summary>
/// FOR INTERNAL USE ONLY.
/// </summary>
protected static ITypeInfo[] ResolveGenericTypes(IMethodInfo method, object[] parameters)
{
ITypeInfo[] genericTypes = method.GetGenericArguments().ToArray();
ITypeInfo[] resolvedTypes = new ITypeInfo[genericTypes.Length];
IParameterInfo[] parameterInfos = method.GetParameters().ToArray();
for (int idx = 0; idx < genericTypes.Length; ++idx)
resolvedTypes[idx] = ResolveGenericType(genericTypes[idx], parameters, parameterInfos);
return resolvedTypes;
}
private static GenericTypeParameterBuilder[] CopyGenericArguments(
IMethodInfo methodToCopyGenericsFrom,
Dictionary<String, GenericTypeParameterBuilder> name2GenericType,
ApplyGenArgs genericParameterGenerator)
{
var originalGenericArguments = methodToCopyGenericsFrom.GetGenericArguments();
if (originalGenericArguments.Length == 0)
{
return null;
}
var argumentNames = GetArgumentNames(originalGenericArguments);
var newGenericParameters = genericParameterGenerator(argumentNames);
for (var i = 0; i < newGenericParameters.Length; i++)
{
try
{
var attributes = originalGenericArguments[i].GenericParameterAttributes();
newGenericParameters[i].SetGenericParameterAttributes(attributes);
var constraints = AdjustGenericConstraints(methodToCopyGenericsFrom, newGenericParameters, originalGenericArguments, originalGenericArguments[i].GetGenericParameterConstraints());
newGenericParameters[i].SetInterfaceConstraints(constraints);
CopyNonInheritableAttributes(newGenericParameters[i], originalGenericArguments[i]);
}
catch (NotSupportedException)
{
// Doesnt matter
newGenericParameters[i].SetGenericParameterAttributes(GenericParameterAttributes.None);
}
name2GenericType[argumentNames[i]] = newGenericParameters[i];
}
return newGenericParameters;
}
