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