public void GetConcreteMethods_succeeds_for_generic_method(string methodName, Type[] genericArguments)
{
var method = GetMethod(methodName);
var concreteMethods = GenericTypeResolver.GetConcreteMethods(method)
.ToArray( );
Assert.NotNull(concreteMethods);
if (genericArguments == null)
{
Assert.Empty(concreteMethods);
}
else
{
Assert.NotEmpty(concreteMethods);
Assert.Equal(1, concreteMethods.Length);
var constructedMethod = method.MakeGenericMethod(genericArguments);
Assert.Equal(constructedMethod, concreteMethods[0]);
foreach (var parameter in constructedMethod.GetParameters( ))
{
var instances = TypeCreator.GetCreators(parameter.ParameterType);
Assert.Equal(1, instances.Count);
}
}
}
public void GetConcreteMethods_succeeds_for_concrete_method( )
{
var method = GetMethod("ConcreteMethod");
var concreteMethods = GenericTypeResolver.GetConcreteMethods(method);
Assert.Equal(method, Assert.Single(concreteMethods));
}
public void GetCreators_returns_expected_instances_for_generic_method_argument_types(MethodInfo genericMethod)
{
var concreteMethods = GenericTypeResolver.GetConcreteMethods(genericMethod);
foreach (var method in concreteMethods)
{
Type genericType = method.GetParameters( ).Single( ).ParameterType;
var creators = TypeCreator.GetCreators(genericType);
TestCreators(genericType, new[] { genericType }, creators);
}
}
public void GetConcreteMethods_succeeds_for_generic_class_method( )
{
string methodName = "GenericMethod";
Type type = typeof(GenericMethodClass <>);
var method = type.GetMethod(methodName);
Assert.NotNull(method);
var concreteMethods = GenericTypeResolver.GetConcreteMethods(method);
var constructedType = type.MakeGenericType(typeof(SimpleParameter));
var constructedMethod = type.GetMethod(methodName);
Assert.Equal(constructedMethod, Assert.Single(concreteMethods));
}
public void GetConcreteMethods_succeeds_for_generic_method_with_multiple_resolutions( )
{
const string methodName = "GenericMethod_MultipleFactoryResolutions";
var method = GetMethod(methodName);
var concreteMethods = GenericTypeResolver.GetConcreteMethods(method)
.ToArray( );
Assert.Equal(2, concreteMethods.Length);
foreach (var concreteMethod in concreteMethods)
{
var parameter = concreteMethod.GetParameters( ).Single( );
var instances = TypeCreator.GetCreators(parameter.ParameterType);
Assert.Equal(1, instances.Count);
}
}
public void GetConcreteMethods_succeeds_for_generic_method_with_multiple_generic_resolutions(MethodInfo method)
{
Type[] resolutionArguments = new[] { typeof(int), typeof(double) };
var concreteMethods = GenericTypeResolver.GetConcreteMethods(method)
.ToArray( );
Assert.NotNull(concreteMethods);
Assert.NotEmpty(concreteMethods);
Assert.Equal(2, concreteMethods.Length);
foreach (var m in concreteMethods)
{
Type[] genericArguments = m.GetGenericArguments( );
Assert.NotEmpty(genericArguments);
Assert.Contains(genericArguments[0], resolutionArguments);
}
}
public static ICollection <MethodInfo> GetConcreteMethods(MethodInfo genericMethod)
{
return(GenericTypeResolver.GetConcreteMethods(genericMethod, Binding.EmptyBindings));
}
