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)); }