/// <inheritdoc/>
public virtual ValueTask <IReadOnlyCollection <ITheoryDataRow>?> GetData(
_IAttributeInfo dataAttribute,
_IMethodInfo testMethod)
{
Guard.ArgumentNotNull(dataAttribute);
Guard.ArgumentNotNull(testMethod);
if (dataAttribute is _IReflectionAttributeInfo reflectionDataAttribute &&
testMethod is _IReflectionMethodInfo reflectionTestMethod)
{
var attribute = (DataAttribute)reflectionDataAttribute.Attribute;
try
{
return(attribute.GetData(reflectionTestMethod.MethodInfo));
}
catch (ArgumentException)
{
// If we couldn't find the data on the base type, check if it is in current type.
// This allows base classes to specify data that exists on a sub type, but not on the base type.
var reflectionTestMethodType = (_IReflectionTypeInfo)reflectionTestMethod.Type;
if (attribute is MemberDataAttribute memberDataAttribute && memberDataAttribute.MemberType == null)
{
memberDataAttribute.MemberType = reflectionTestMethodType.Type;
}
return(attribute.GetData(reflectionTestMethod.MethodInfo));
}
}
return(new(default(IReadOnlyCollection <ITheoryDataRow>)));
}
/// <inheritdoc/>
public virtual IEnumerable <object?[]>?GetData(
_IAttributeInfo dataAttribute,
_IMethodInfo testMethod)
{
Guard.ArgumentNotNull(nameof(dataAttribute), dataAttribute);
Guard.ArgumentNotNull(nameof(testMethod), testMethod);
if (dataAttribute is _IReflectionAttributeInfo reflectionDataAttribute &&
testMethod is _IReflectionMethodInfo reflectionTestMethod)
{
var attribute = (DataAttribute)reflectionDataAttribute.Attribute;
try
{
return(attribute.GetData(reflectionTestMethod.MethodInfo));
}
catch (ArgumentException)
{
// If we couldn't find the data on the base type, check if it is in current type.
// This allows base classes to specify data that exists on a sub type, but not on the base type.
var reflectionTestMethodType = (_IReflectionTypeInfo)reflectionTestMethod.Type;
if (attribute is MemberDataAttribute memberDataAttribute && memberDataAttribute.MemberType == null)
{
memberDataAttribute.MemberType = reflectionTestMethodType.Type;
}
return(attribute.GetData(reflectionTestMethod.MethodInfo));
}
}
return(null);
}
/// <summary>
/// Initializes a new instance of the <see cref="Xunit2MethodInfo"/> class.
/// </summary>
/// <param name="v3MethodInfo">The v3 method info to wrap.</param>
public Xunit2MethodInfo(_IMethodInfo v3MethodInfo)
{
V3MethodInfo = Guard.ArgumentNotNull(nameof(v3MethodInfo), v3MethodInfo);
ReturnType = new Xunit2TypeInfo(V3MethodInfo.ReturnType);
Type = new Xunit2TypeInfo(V3MethodInfo.Type);
}
/// <summary>
/// Gets all the custom attributes for the method that are of the given type.
/// </summary>
/// <param name="methodInfo">The method</param>
/// <param name="attributeType">The type of the attribute</param>
/// <returns>The matching attributes that decorate the method</returns>
public static IEnumerable <_IAttributeInfo> GetCustomAttributes(this _IMethodInfo methodInfo, Type attributeType)
{
Guard.ArgumentNotNull(nameof(methodInfo), methodInfo);
Guard.ArgumentNotNull(nameof(attributeType), attributeType);
Guard.NotNull("Attribute type cannot be a generic type parameter", attributeType.AssemblyQualifiedName);
return(methodInfo.GetCustomAttributes(attributeType.AssemblyQualifiedName));
}
/// <summary>
/// Gets all the custom attributes for the method that are of the given type.
/// </summary>
/// <param name="methodInfo">The method</param>
/// <param name="attributeType">The type of the attribute</param>
/// <returns>The matching attributes that decorate the method</returns>
public static IReadOnlyCollection <_IAttributeInfo> GetCustomAttributes(this _IMethodInfo methodInfo, Type attributeType)
{
Guard.ArgumentNotNull(methodInfo);
Guard.ArgumentNotNull(attributeType);
Guard.NotNull("Attribute type cannot be a generic type parameter", attributeType.AssemblyQualifiedName);
return(methodInfo.GetCustomAttributes(attributeType.AssemblyQualifiedName));
}
static MethodInfo?GetMethodInfoFromIMethodInfo(this Type type, _IMethodInfo methodInfo)
{
var methods = methodInfo.IsStatic ? type.GetRuntimeMethods() : type.GetMethods();
return
(methods
.Where(method => method.IsPublic == methodInfo.IsPublic && method.IsStatic == methodInfo.IsStatic && method.Name == methodInfo.Name)
.FirstOrDefault());
}
/// <inheritdoc/>
public override bool SupportsDiscoveryEnumeration(
_IAttributeInfo dataAttribute,
_IMethodInfo testMethod)
{
Guard.ArgumentNotNull(dataAttribute);
Guard.ArgumentNotNull(testMethod);
return(!dataAttribute.GetNamedArgument <bool>("DisableDiscoveryEnumeration"));
}
/// <inheritdoc/>
public virtual bool SupportsDiscoveryEnumeration(
_IAttributeInfo dataAttribute,
_IMethodInfo testMethod)
{
Guard.ArgumentNotNull(dataAttribute);
Guard.ArgumentNotNull(testMethod);
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="TestMethod"/> class.
/// </summary>
/// <param name="testClass">The test class</param>
/// <param name="method">The test method</param>
/// <param name="uniqueID">The unique ID for the test method (only used to override default behavior in testing scenarios)</param>
public TestMethod(
_ITestClass testClass,
_IMethodInfo method,
string?uniqueID = null)
{
this.testClass = Guard.ArgumentNotNull(nameof(testClass), testClass);
this.method = Guard.ArgumentNotNull(nameof(method), method);
this.uniqueID = uniqueID ?? UniqueIDGenerator.ForTestMethod(testClass.UniqueID, this.method.Name);
}
/// <summary>
/// Used for de-serialization.
/// </summary>
protected TestMethod(
SerializationInfo info,
StreamingContext context)
{
testClass = Guard.NotNull("Could not retrieve TestClass from serialization", info.GetValue <_ITestClass>("TestClass"));
uniqueID = Guard.NotNull("Could not retrieve UniqueID from serialization", info.GetValue <string>("UniqueID"));
var methodName = Guard.NotNull("Could not retrieve MethodName from serialization", info.GetValue <string>("MethodName"));
method = Guard.NotNull($"Could not find test method {methodName} on test class {testClass.Class.Name}", TestClass.Class.GetMethod(methodName, true));
}
/// <summary>
/// Converts an <see cref="_IMethodInfo"/> into a <see cref="MethodInfo"/>, if possible (for example, this
/// will not work when the test method is based on source code rather than binaries).
/// </summary>
/// <param name="methodInfo">The method to convert</param>
/// <returns>The runtime method, if available; <c>null</c>, otherwise</returns>
public static MethodInfo?ToRuntimeMethod(this _IMethodInfo methodInfo)
{
Guard.ArgumentNotNull(nameof(methodInfo), methodInfo);
if (methodInfo is _IReflectionMethodInfo reflectionMethodInfo)
{
return(reflectionMethodInfo.MethodInfo);
}
return(methodInfo.Type.ToRuntimeType()?.GetMethodInfoFromIMethodInfo(methodInfo));
}
public static void ResolveGenericType(string methodName, object?[] parameters, Type[] expected)
{
var methodInfo = typeof(ResolveGenericMethodTests).GetMethod(methodName);
Assert.NotNull(methodInfo);
_IMethodInfo method = Reflector.Wrap(methodInfo);
Type[] actual = method.ResolveGenericTypes(parameters).Select(t => ((ReflectionTypeInfo)t).Type).ToArray();
Assert.Equal(expected, actual);
}
static Dictionary <string, List <string> > GetTraits(_IMethodInfo method)
{
var result = new Dictionary <string, List <string> >(StringComparer.OrdinalIgnoreCase);
foreach (var traitAttribute in method.GetCustomAttributes(typeof(TraitAttribute)))
{
var ctorArgs = traitAttribute.GetConstructorArguments().ToList();
result.Add((string)ctorArgs[0] !, (string)ctorArgs[1] !);
}
return(result);
}
public static _ITestMethod TestMethod(
_IMethodInfo methodInfo,
_ITestClass testClass,
string?uniqueID = null)
{
uniqueID ??= "method-id";
var result = Substitute.For <_ITestMethod, InterfaceProxy <_ITestMethod> >();
result.Method.Returns(methodInfo);
result.TestClass.Returns(testClass);
result.UniqueID.Returns(uniqueID);
return(result);
}
/// <inheritdoc/>
public virtual IEnumerable <object?[]> GetData(
_IAttributeInfo dataAttribute,
_IMethodInfo testMethod)
{
// The data from GetConstructorArguments does not maintain its original form (in particular, collections
// end up as generic IEnumerable<T>). So we end up needing to call .ToArray() on the enumerable so that
// we can restore the correct argument type from InlineDataAttribute.
//
// In addition, [InlineData(null)] gets translated into passing a null array, not a single array with a null
// value in it, which is why the null coalesce operator is required (this is covered by the acceptance test
// in Xunit2TheoryAcceptanceTests.InlineDataTests.SingleNullValuesWork).
var args = (IEnumerable <object?>?)dataAttribute.GetConstructorArguments().Single() ?? new object?[] { null };
return(new[] { args.ToArray() });
}
static (string displayName, Exception?initException, _IMethodInfo method, _ITypeInfo[]? methodGenericTypes) Initialize(
string baseDisplayName,
_ITestMethod testMethod,
object?[]?testMethodArguments)
{
string? displayName = null;
Exception?initException = null;
_ITypeInfo[]? methodGenericTypes = null;
var method = testMethod.Method;
if (testMethodArguments != null)
{
if (method is _IReflectionMethodInfo reflectionMethod)
{
try
{
testMethodArguments = reflectionMethod.MethodInfo.ResolveMethodArguments(testMethodArguments);
}
catch (Exception ex)
{
initException = ex;
testMethodArguments = null;
displayName = $"{baseDisplayName}(???)";
}
}
}
if (testMethodArguments != null && method.IsGenericMethodDefinition)
{
methodGenericTypes = method.ResolveGenericTypes(testMethodArguments);
method = method.MakeGenericMethod(methodGenericTypes);
}
if (displayName == null)
{
displayName = method.GetDisplayNameWithArguments(baseDisplayName, testMethodArguments, methodGenericTypes);
}
return(displayName, initException, method, methodGenericTypes);
}
/// <inheritdoc/>
public virtual bool SupportsDiscoveryEnumeration(
_IAttributeInfo dataAttribute,
_IMethodInfo testMethod) => true;
