void Initialize(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo type, IMethodInfo method, IAttributeInfo factAttribute, object[] arguments)
{
string displayNameBase = factAttribute.GetNamedArgument<string>("DisplayName") ?? type.Name + "." + method.Name;
ITypeInfo[] resolvedTypes = null;
if (arguments != null && method.IsGenericMethodDefinition)
{
resolvedTypes = ResolveGenericTypes(method, arguments);
method = method.MakeGenericMethod(resolvedTypes);
}
Assembly = assembly;
Class = type;
Method = method;
Arguments = arguments;
DisplayName = GetDisplayNameWithArguments(displayNameBase, arguments, resolvedTypes);
SkipReason = factAttribute.GetNamedArgument<string>("Skip");
Traits = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
TestCollection = testCollection;
foreach (IAttributeInfo traitAttribute in Method.GetCustomAttributes(typeof(TraitAttribute))
.Concat(Class.GetCustomAttributes(typeof(TraitAttribute))))
{
var ctorArgs = traitAttribute.GetConstructorArguments().ToList();
Traits.Add((string)ctorArgs[0], (string)ctorArgs[1]);
}
uniqueID = new Lazy<string>(GetUniqueID, true);
}
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();
}
void Initialize(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo type, IMethodInfo method, IAttributeInfo factAttribute, object[] arguments)
{
string displayNameBase = factAttribute.GetNamedArgument<string>("DisplayName") ?? type.Name + "." + method.Name;
ITypeInfo[] resolvedTypes = null;
if (arguments != null && method.IsGenericMethodDefinition)
{
resolvedTypes = ResolveGenericTypes(method, arguments);
method = method.MakeGenericMethod(resolvedTypes);
}
Assembly = assembly;
Class = type;
Method = method;
Arguments = arguments;
DisplayName = GetDisplayNameWithArguments(displayNameBase, arguments, resolvedTypes);
SkipReason = factAttribute.GetNamedArgument<string>("Skip");
Traits = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
TestCollection = testCollection;
foreach (var traitAttribute in Method.GetCustomAttributes(typeof(ITraitAttribute))
.Concat(Class.GetCustomAttributes(typeof(ITraitAttribute))))
{
var discovererAttribute = traitAttribute.GetCustomAttributes(typeof(TraitDiscovererAttribute)).First();
var discoverer = ExtensibilityPointFactory.GetTraitDiscoverer(discovererAttribute);
if (discoverer != null)
foreach (var keyValuePair in discoverer.GetTraits(traitAttribute))
Traits.Add(keyValuePair.Key, keyValuePair.Value);
}
uniqueID = new Lazy<string>(GetUniqueID, true);
}
void Initialize(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo type, IMethodInfo method, IAttributeInfo factAttribute, object[] arguments)
{
string displayNameBase = factAttribute.GetNamedArgument <string>("DisplayName") ?? type.Name + "." + method.Name;
ITypeInfo[] resolvedTypes = null;
if (arguments != null && method.IsGenericMethodDefinition)
{
resolvedTypes = ResolveGenericTypes(method, arguments);
method = method.MakeGenericMethod(resolvedTypes);
}
Assembly = assembly;
Class = type;
Method = method;
Arguments = arguments;
DisplayName = GetDisplayNameWithArguments(displayNameBase, arguments, resolvedTypes);
SkipReason = factAttribute.GetNamedArgument <string>("Skip");
Traits = new Dictionary <string, List <string> >(StringComparer.OrdinalIgnoreCase);
TestCollection = testCollection;
foreach (IAttributeInfo traitAttribute in Method.GetCustomAttributes(typeof(TraitAttribute))
.Concat(Class.GetCustomAttributes(typeof(TraitAttribute))))
{
var ctorArgs = traitAttribute.GetConstructorArguments().ToList();
Traits.Add((string)ctorArgs[0], (string)ctorArgs[1]);
}
uniqueID = new Lazy <string>(GetUniqueID, true);
}
public void GenericMethodInstantiations()
{
MethodInfo target = typeof(ReflectionPolicySample.Class1).GetMethod("Method1");
IMethodInfo method = GetMethod(target);
WrapperAssert.AreEquivalent(target.MakeGenericMethod(typeof(int)),
method.MakeGenericMethod(new ITypeInfo[] { GetType(typeof(int)) }), false);
}
IEnumerable <TestMethod> ITestBuilder.BuildFrom(IMethodInfo method, Test suite)
{
if (method.IsGenericMethodDefinition && _type != null)
{
var gm = method.MakeGenericMethod(_type);
return(BuildFrom(gm, suite));
}
return(BuildFrom(method, suite));
}
IEnumerable <TestMethod> ITestBuilder.BuildFrom(IMethodInfo method, Test suite)
{
if (!method.IsGenericMethodDefinition || _type == null)
{
return(BuildFrom(method, suite));
}
var genericMethod = method.MakeGenericMethod(_type);
return(BuildFrom(genericMethod, suite));
}
private IMethodInfo DefineMethod([NotNull] IMethodInfo method, [NotNull] Type[] genericArgs)
{
if (method == null)
{
throw new ArgumentNullException(nameof(method));
}
if (genericArgs == null)
{
throw new ArgumentNullException(nameof(genericArgs));
}
return(method.IsGenericMethodDefinition ? method.MakeGenericMethod(genericArgs) : method);
}
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));
}
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();
}
void Initialize(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo type, IMethodInfo method, IAttributeInfo factAttribute, object[] arguments)
{
string displayNameBase = factAttribute.GetNamedArgument <string>("DisplayName") ?? type.Name + "." + method.Name;
ITypeInfo[] resolvedTypes = null;
if (arguments != null && method.IsGenericMethodDefinition)
{
resolvedTypes = ResolveGenericTypes(method, arguments);
method = method.MakeGenericMethod(resolvedTypes);
}
Assembly = assembly;
Class = type;
Method = method;
Arguments = arguments;
DisplayName = GetDisplayNameWithArguments(displayNameBase, arguments, resolvedTypes);
SkipReason = factAttribute.GetNamedArgument <string>("Skip");
Traits = new Dictionary <string, List <string> >(StringComparer.OrdinalIgnoreCase);
TestCollection = testCollection;
foreach (var traitAttribute in Method.GetCustomAttributes(typeof(ITraitAttribute))
.Concat(Class.GetCustomAttributes(typeof(ITraitAttribute))))
{
var discovererAttribute = traitAttribute.GetCustomAttributes(typeof(TraitDiscovererAttribute)).First();
var args = discovererAttribute.GetConstructorArguments().Cast <string>().ToList();
var discovererType = Reflector.GetType(args[1], args[0]);
if (discovererType != null)
{
var discoverer = ExtensibilityPointFactory.GetTraitDiscoverer(discovererType);
foreach (var keyValuePair in discoverer.GetTraits(traitAttribute))
{
Traits.Add(keyValuePair.Key, keyValuePair.Value);
}
}
}
uniqueID = new Lazy <string>(GetUniqueID, true);
}
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));
}
public override MethodInfo MakeGenericMethod(params Type[] typeArguments)
{
return(adapter.MakeGenericMethod(Reflector.Wrap(typeArguments)).Resolve(false));
}
public IMethodInfo MakeGenericMethod(params ITypeInfo[] typeArguments)
{
return(_inner.MakeGenericMethod(typeArguments));
}
public IMethodInfo MakeGenericMethod(params Type[] typeArguments)
{
return(_baseInfo.MakeGenericMethod(typeArguments));
}
IEnumerable <TestMethod> ITestBuilder.BuildFrom(IMethodInfo method, Test suite)
{
return(BuildFrom(method.MakeGenericMethod(_type), suite));
}
