internal static Type GetTestCollectionFactoryType(IAttributeInfo collectionBehavior)
{
if (collectionBehavior == null)
{
return(typeof(CollectionPerClassTestCollectionFactory));
}
var ctorArgs = collectionBehavior.GetConstructorArguments().ToList();
if (ctorArgs.Count == 0)
{
return(typeof(CollectionPerClassTestCollectionFactory));
}
if (ctorArgs.Count == 1 && (CollectionBehavior)ctorArgs[0] == CollectionBehavior.CollectionPerAssembly)
{
return(typeof(CollectionPerAssemblyTestCollectionFactory));
}
var result = Reflector.GetType((string)ctorArgs[1], (string)ctorArgs[0]);
if (!typeof(IXunitTestCollectionFactory).IsAssignableFrom(result) || result.GetConstructor(new[] { typeof(IAssemblyInfo) }) == null)
{
return(typeof(CollectionPerClassTestCollectionFactory));
}
return(result);
}
static ITestCaseOrderer GetTestCaseOrderer(IAttributeInfo ordererAttribute)
{
var args = ordererAttribute.GetConstructorArguments().Cast <string>().ToList();
var ordererType = Reflector.GetType(args[1], args[0]);
return((ITestCaseOrderer)Activator.CreateInstance(ordererType));
}
/// <summary>
/// Core implementation to discover unit tests in a given test class.
/// </summary>
/// <param name="type">The test class.</param>
/// <param name="includeSourceInformation">Set to <c>true</c> to attempt to include source information.</param>
/// <param name="messageBus">The message sink to send discovery messages to.</param>
/// <returns>Returns <c>true</c> if discovery should continue; <c>false</c> otherwise.</returns>
protected virtual bool FindImpl(ITypeInfo type, bool includeSourceInformation, IMessageBus messageBus)
{
string currentDirectory = Directory.GetCurrentDirectory();
var testCollection = TestCollectionFactory.Get(type);
try
{
if (!String.IsNullOrEmpty(assemblyInfo.AssemblyPath))
{
Directory.SetCurrentDirectory(Path.GetDirectoryName(assemblyInfo.AssemblyPath));
}
foreach (var method in type.GetMethods(includePrivateMethods: true))
{
var factAttribute = method.GetCustomAttributes(typeof(FactAttribute)).FirstOrDefault();
if (factAttribute != null)
{
var discovererAttribute = factAttribute.GetCustomAttributes(typeof(TestCaseDiscovererAttribute)).FirstOrDefault();
if (discovererAttribute != null)
{
var args = discovererAttribute.GetConstructorArguments().Cast <string>().ToList();
var discovererType = Reflector.GetType(args[1], args[0]);
if (discovererType != null)
{
var discoverer = GetDiscoverer(discovererType);
if (discoverer != null)
{
foreach (var testCase in discoverer.Discover(testCollection, assemblyInfo, type, method, factAttribute))
{
if (!messageBus.QueueMessage(new TestCaseDiscoveryMessage(UpdateTestCaseWithSourceInfo(testCase, includeSourceInformation))))
{
return(false);
}
}
}
}
else
{
messageAggregator.Add(new EnvironmentalWarning {
Message = String.Format("Could not create discoverer type '{0}, {1}'", args[0], args[1])
});
}
}
}
}
}
catch (Exception ex)
{
messageAggregator.Add(new EnvironmentalWarning {
Message = String.Format("Exception during discovery:{0}{1}", Environment.NewLine, ex)
});
}
finally
{
Directory.SetCurrentDirectory(currentDirectory);
}
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="TestFrameworkProxy"/> class.
/// </summary>
/// <param name="testAssemblyObject">The test assembly (expected to implement <see cref="IAssemblyInfo"/>).</param>
/// <param name="sourceInformationProviderObject">The source information provider (expected to implement <see cref="ISourceInformationProvider"/>).</param>
public TestFrameworkProxy(object testAssemblyObject, object sourceInformationProviderObject)
{
var testAssembly = (IAssemblyInfo)testAssemblyObject;
var sourceInformationProvider = (ISourceInformationProvider)sourceInformationProviderObject;
Type testFrameworkType = typeof(XunitTestFramework);
try
{
var attr = testAssembly.GetCustomAttributes(typeof(TestFrameworkAttribute)).FirstOrDefault();
if (attr != null)
{
var ctorArgs = attr.GetConstructorArguments().Cast <string>().ToArray();
testFrameworkType = Reflector.GetType(ctorArgs[1], ctorArgs[0]);
}
}
catch
{
// TODO: Log environmental error
}
try
{
testFramework = (ITestFramework)Activator.CreateInstance(testFrameworkType);
}
catch
{
// TODO: Log environmental error
testFramework = new XunitTestFramework();
}
SourceInformationProvider = sourceInformationProvider;
}
static Type GetTestCollectionFactoryType(IAttributeInfo collectionBehaviorAttribute)
{
if (collectionBehaviorAttribute == null)
{
return(typeof(CollectionPerClassTestCollectionFactory));
}
var ctorArgs = collectionBehaviorAttribute.GetConstructorArguments().ToList();
if (ctorArgs.Count == 0)
{
return(typeof(CollectionPerClassTestCollectionFactory));
}
if (ctorArgs.Count == 1)
{
if ((CollectionBehavior)ctorArgs[0] == CollectionBehavior.CollectionPerAssembly)
{
return(typeof(CollectionPerAssemblyTestCollectionFactory));
}
return(typeof(CollectionPerClassTestCollectionFactory));
}
var result = Reflector.GetType((string)ctorArgs[1], (string)ctorArgs[0]);
if (result == null || !IsCompatibleTestCollectionFactory(result))
{
return(typeof(CollectionPerClassTestCollectionFactory));
}
return(result);
}
static ITestCaseOrderer GetXunitTestCaseOrderer(IAttributeInfo ordererAttribute)
{
var args = ordererAttribute.GetConstructorArguments().Cast <string>().ToList();
var ordererType = Reflector.GetType(args[1], args[0]);
return(ExtensibilityPointFactory.GetTestCaseOrderer(ordererType));
}
/// <inheritdoc/>
protected XunitTestClass(SerializationInfo info, StreamingContext context)
{
TestCollection = info.GetValue <ITestCollection>("TestCollection");
var assemblyName = info.GetString("ClassAssemblyName");
var typeName = info.GetString("ClassTypeName");
Class = Reflector.Wrap(Reflector.GetType(assemblyName, typeName));
}
/// <inheritdoc/>
public void SetData(XunitSerializationInfo info)
{
TestCollection = info.GetValue <ITestCollection>("TestCollection");
var assemblyName = info.GetString("ClassAssemblyName");
var typeName = info.GetString("ClassTypeName");
Class = Reflector.Wrap(Reflector.GetType(assemblyName, typeName));
}
/// <summary>
/// Gets the <see cref="Type"/> of the class under test.
/// </summary>
/// <returns>The type under test, if possible; null, if not available.</returns>
protected Type GetRuntimeClass()
{
var reflectionTypeInfo = Class as IReflectionTypeInfo;
if (reflectionTypeInfo != null)
{
return(reflectionTypeInfo.Type);
}
return(Reflector.GetType(Assembly.Name, Class.Name));
}
Type GetRuntimeClass()
{
var testClass = TestCase.TestMethod.TestClass;
var reflectionTypeInfo = testClass.Class as IReflectionTypeInfo;
if (reflectionTypeInfo != null)
{
return(reflectionTypeInfo.Type);
}
return(Reflector.GetType(testClass.TestCollection.TestAssembly.Assembly.Name, testClass.Class.Name));
}
/// <inheritdoc/>
protected XunitTestCollection(SerializationInfo info, StreamingContext context)
{
DisplayName = info.GetString("DisplayName");
var assemblyName = info.GetString("DeclarationAssemblyName");
var typeName = info.GetString("DeclarationTypeName");
if (!String.IsNullOrWhiteSpace(assemblyName) && String.IsNullOrWhiteSpace(typeName))
{
CollectionDefinition = Reflector.Wrap(Reflector.GetType(assemblyName, typeName));
}
}
/// <inheritdoc/>
public IEnumerable <IXunitTestCase> Discover(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo testClass, IMethodInfo testMethod, IAttributeInfo factAttribute)
{
// Special case Skip, because we want a single Skip (not one per data item), and a skipped test may
// not actually have any data (which is quasi-legal, since it's skipped).
if (factAttribute.GetNamedArgument <string>("Skip") != null)
{
return new[] { new XunitTestCase(testCollection, assembly, testClass, testMethod, factAttribute) }
}
;
try
{
using (var memoryStream = new MemoryStream())
{
var results = new List <XunitTestCase>();
var dataAttributes = testMethod.GetCustomAttributes(typeof(DataAttribute));
foreach (var dataAttribute in dataAttributes)
{
var discovererAttribute = dataAttribute.GetCustomAttributes(typeof(DataDiscovererAttribute)).First();
var args = discovererAttribute.GetConstructorArguments().Cast <string>().ToList();
var discovererType = Reflector.GetType(args[1], args[0]);
var discoverer = ExtensibilityPointFactory.GetDataDiscoverer(discovererType);
// GetData may return null, but that's okay; we'll let the NullRef happen and then catch it
// down below so that we get the composite test case.
foreach (object[] dataRow in discoverer.GetData(dataAttribute, testMethod))
{
// Attempt to serialize the test case, since we need a way to uniquely identify a test
// and serialization is the best way to do that. If it's not serializable, this will
// throw and we will fall back to a single theory test case that gets its data
// at runtime.
var testCase = new XunitTestCase(testCollection, assembly, testClass, testMethod, factAttribute, dataRow);
SerializationHelper.Serialize(testCase);
results.Add(testCase);
}
}
// REVIEW: Could we re-write LambdaTestCase to just be for exceptions?
if (results.Count == 0)
{
results.Add(new LambdaTestCase(testCollection, assembly, testClass, testMethod, factAttribute, () => { throw new InvalidOperationException("No data found for " + testClass.Name + "." + testMethod.Name); }));
}
return(results);
}
}
catch
{
return(new XunitTestCase[] { new XunitTheoryTestCase(testCollection, assembly, testClass, testMethod, factAttribute) });
}
}
}
/// <summary>
/// Gets a test case orderer, as specified in a reflected <see cref="TestCaseOrdererAttribute"/>.
/// </summary>
/// <param name="testCaseOrdererAttribute">The test case orderer attribute.</param>
/// <returns>The test case orderer, if the type is loadable; <c>null</c>, otherwise.</returns>
public static ITestCaseOrderer GetTestCaseOrderer(IAttributeInfo testCaseOrdererAttribute)
{
var args = testCaseOrdererAttribute.GetConstructorArguments().Cast <string>().ToList();
var ordererType = Reflector.GetType(args[1], args[0]);
if (ordererType == null)
{
return(null);
}
return(GetTestCaseOrderer(ordererType));
}
/// <summary>
/// Gets a test framework discoverer, as specified in a reflected <see cref="TestFrameworkDiscovererAttribute"/>.
/// </summary>
public static ITestFrameworkTypeDiscoverer GetTestFrameworkTypeDiscoverer(IAttributeInfo testFrameworkAttribute)
{
var args = testFrameworkAttribute.GetConstructorArguments().Cast <string>().ToArray();
var testFrameworkDiscovererType = Reflector.GetType(args[1], args[0]);
if (testFrameworkDiscovererType == null)
{
return(null);
}
return(GetTestFrameworkTypeDiscoverer(testFrameworkDiscovererType));
}
/// <summary>
/// Gets a data discoverer, as specified in a reflected <see cref="DataDiscovererAttribute"/>.
/// </summary>
/// <param name="dataDiscovererAttribute">The data discoverer attribute</param>
/// <returns>The data discoverer, if the type is loadable; <c>null</c>, otherwise.</returns>
public static IDataDiscoverer GetDataDiscoverer(IAttributeInfo dataDiscovererAttribute)
{
var args = dataDiscovererAttribute.GetConstructorArguments().Cast <string>().ToList();
var discovererType = Reflector.GetType(args[1], args[0]);
if (discovererType == null)
{
return(null);
}
return(GetDataDiscoverer(discovererType));
}
/// <inheritdoc/>
public void SetData(XunitSerializationInfo info)
{
DisplayName = info.GetString("DisplayName");
TestAssembly = info.GetValue <ITestAssembly>("TestAssembly");
UniqueID = Guid.Parse(info.GetString("UniqueID"));
var assemblyName = info.GetString("DeclarationAssemblyName");
var typeName = info.GetString("DeclarationTypeName");
if (!String.IsNullOrWhiteSpace(assemblyName) && String.IsNullOrWhiteSpace(typeName))
{
CollectionDefinition = Reflector.Wrap(Reflector.GetType(assemblyName, typeName));
}
}
/// <inheritdoc/>
protected TestCollection(SerializationInfo info, StreamingContext context)
{
DisplayName = info.GetString("DisplayName");
TestAssembly = info.GetValue <ITestAssembly>("TestAssembly");
UniqueID = Guid.Parse(info.GetString("UniqueID"));
var assemblyName = info.GetString("DeclarationAssemblyName");
var typeName = info.GetString("DeclarationTypeName");
if (!String.IsNullOrWhiteSpace(assemblyName) && String.IsNullOrWhiteSpace(typeName))
{
CollectionDefinition = Reflector.Wrap(Reflector.GetType(assemblyName, typeName));
}
}
/// <inheritdoc/>
protected XunitTestCase(SerializationInfo info, StreamingContext context)
{
string assemblyName = info.GetString("AssemblyName");
string typeName = info.GetString("TypeName");
string methodName = info.GetString("MethodName");
object[] arguments = (object[])info.GetValue("Arguments", typeof(object[]));
var testCollection = (ITestCollection)info.GetValue("TestCollection", typeof(ITestCollection));
var type = Reflector.GetType(assemblyName, typeName);
var typeInfo = Reflector.Wrap(type);
var methodInfo = Reflector.Wrap(type.GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static));
var factAttribute = methodInfo.GetCustomAttributes(typeof(FactAttribute)).Single();
Initialize(testCollection, Reflector.Wrap(type.Assembly), typeInfo, methodInfo, factAttribute, arguments);
}
/// <summary>
/// Finds the tests on a test method.
/// </summary>
/// <param name="testMethod">The test method.</param>
/// <param name="includeSourceInformation">Set to <c>true</c> to indicate that source information should be included.</param>
/// <param name="messageBus">The message bus to report discovery messages to.</param>
/// <param name="discoveryOptions">The options used by the test framework during discovery.</param>
/// <returns>Return <c>true</c> to continue test discovery, <c>false</c>, otherwise.</returns>
protected virtual bool FindTestsForMethod(ITestMethod testMethod, bool includeSourceInformation, IMessageBus messageBus, ITestFrameworkOptions discoveryOptions)
{
var factAttribute = testMethod.Method.GetCustomAttributes(typeof(FactAttribute)).FirstOrDefault();
if (factAttribute == null)
{
return(true);
}
var testCaseDiscovererAttribute = factAttribute.GetCustomAttributes(typeof(XunitTestCaseDiscovererAttribute)).FirstOrDefault();
if (testCaseDiscovererAttribute == null)
{
return(true);
}
var args = testCaseDiscovererAttribute.GetConstructorArguments().Cast <string>().ToList();
var discovererType = Reflector.GetType(args[1], args[0]);
if (discovererType == null)
{
return(true);
}
var discoverer = GetDiscoverer(discovererType);
if (discoverer == null)
{
return(true);
}
var methodDisplayString = discoveryOptions.GetValue <string>(TestOptionsNames.Discovery.MethodDisplay, null);
var methodDisplay = methodDisplayString == null ? TestMethodDisplay.ClassAndMethod : (TestMethodDisplay)Enum.Parse(typeof(TestMethodDisplay), methodDisplayString);
foreach (var testCase in discoverer.Discover(methodDisplay, testMethod, factAttribute))
{
if (!ReportDiscoveredTestCase(testCase, includeSourceInformation, messageBus))
{
return(false);
}
}
return(true);
}
/// <inheritdoc/>
protected override async Task AfterTestCaseStartingAsync()
{
await base.AfterTestCaseStartingAsync();
try
{
var dataAttributes = TestCase.TestMethod.Method.GetCustomAttributes(typeof(DataAttribute));
foreach (var dataAttribute in dataAttributes)
{
var discovererAttribute = dataAttribute.GetCustomAttributes(typeof(DataDiscovererAttribute)).First();
var args = discovererAttribute.GetConstructorArguments().Cast <string>().ToList();
var discovererType = Reflector.GetType(args[1], args[0]);
var discoverer = ExtensibilityPointFactory.GetDataDiscoverer(discovererType);
foreach (var dataRow in discoverer.GetData(dataAttribute, TestCase.TestMethod.Method))
{
toDispose.AddRange(dataRow.OfType <IDisposable>());
ITypeInfo[] resolvedTypes = null;
var methodToRun = TestMethod;
if (methodToRun.IsGenericMethodDefinition)
{
resolvedTypes = TypeUtility.ResolveGenericTypes(TestCase.TestMethod.Method, dataRow);
methodToRun = methodToRun.MakeGenericMethod(resolvedTypes.Select(t => ((IReflectionTypeInfo)t).Type).ToArray());
}
var parameterTypes = methodToRun.GetParameters().Select(p => p.ParameterType).ToArray();
var convertedDataRow = Reflector.ConvertArguments(dataRow, parameterTypes);
var theoryDisplayName = TypeUtility.GetDisplayNameWithArguments(TestCase.TestMethod.Method, DisplayName, convertedDataRow, resolvedTypes);
var test = new XunitTest(TestCase, theoryDisplayName);
testRunners.Add(new XunitTestRunner(test, MessageBus, TestClass, ConstructorArguments, methodToRun, convertedDataRow, SkipReason, BeforeAfterAttributes, Aggregator, CancellationTokenSource));
}
}
}
catch (Exception ex)
{
// Stash the exception so we can surface it during RunTestAsync
dataDiscoveryException = ex;
}
}
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);
}
/// <summary>
/// Finds the tests on a test method.
/// </summary>
/// <param name="testMethod">The test method.</param>
/// <param name="includeSourceInformation">Set to <c>true</c> to indicate that source information should be included.</param>
/// <param name="messageBus">The message bus to report discovery messages to.</param>
/// <returns>Return <c>true</c> to continue test discovery, <c>false</c>, otherwise.</returns>
protected virtual bool FindTestsForMethod(ITestMethod testMethod, bool includeSourceInformation, IMessageBus messageBus)
{
var factAttribute = testMethod.Method.GetCustomAttributes(typeof(FactAttribute)).FirstOrDefault();
if (factAttribute == null)
{
return(true);
}
var testCaseDiscovererAttribute = factAttribute.GetCustomAttributes(typeof(XunitTestCaseDiscovererAttribute)).FirstOrDefault();
if (testCaseDiscovererAttribute == null)
{
return(true);
}
var args = testCaseDiscovererAttribute.GetConstructorArguments().Cast <string>().ToList();
var discovererType = Reflector.GetType(args[1], args[0]);
if (discovererType == null)
{
return(true);
}
var discoverer = GetDiscoverer(discovererType);
if (discoverer == null)
{
return(true);
}
foreach (var testCase in discoverer.Discover(testMethod, factAttribute))
{
if (!ReportDiscoveredTestCase(testCase, includeSourceInformation, messageBus))
{
return(false);
}
}
return(true);
}
static IEnumerable <IAttributeInfo> GetCustomAttributes(MethodInfo method, string assemblyQualifiedAttributeTypeName)
{
var attributeType = Reflector.GetType(assemblyQualifiedAttributeTypeName);
return(GetCustomAttributes(method, attributeType, ReflectionAttributeInfo.GetAttributeUsage(attributeType)));
}
internal static IEnumerable <IAttributeInfo> GetCustomAttributes(Type type, string assemblyQualifiedAttributeTypeName)
{
Type attributeType = Reflector.GetType(assemblyQualifiedAttributeTypeName);
return(GetCustomAttributes(type, attributeType, GetAttributeUsage(attributeType)));
}
/// <inheritdoc/>
public Type GetTestFrameworkType(IAttributeInfo attribute)
{
var args = attribute.GetConstructorArguments().Cast <string>().ToArray();
return(Reflector.GetType(args[1], args[0]));
}
/// <inheritdoc/>
protected override async Task <RunSummary> RunTestAsync()
{
var testRunners = new List <XunitTestRunner>();
var toDispose = new List <IDisposable>();
try
{
var dataAttributes = TestCase.TestMethod.Method.GetCustomAttributes(typeof(DataAttribute));
foreach (var dataAttribute in dataAttributes)
{
var discovererAttribute = dataAttribute.GetCustomAttributes(typeof(DataDiscovererAttribute)).First();
var args = discovererAttribute.GetConstructorArguments().Cast <string>().ToList();
var discovererType = Reflector.GetType(args[1], args[0]);
var discoverer = ExtensibilityPointFactory.GetDataDiscoverer(discovererType);
foreach (var dataRow in discoverer.GetData(dataAttribute, TestCase.TestMethod.Method))
{
toDispose.AddRange(dataRow.OfType <IDisposable>());
ITypeInfo[] resolvedTypes = null;
var methodToRun = TestMethod;
if (methodToRun.IsGenericMethodDefinition)
{
resolvedTypes = TypeUtility.ResolveGenericTypes(TestCase.TestMethod.Method, dataRow);
methodToRun = methodToRun.MakeGenericMethod(resolvedTypes.Select(t => ((IReflectionTypeInfo)t).Type).ToArray());
}
var parameterTypes = methodToRun.GetParameters().Select(p => p.ParameterType).ToArray();
var convertedDataRow = Reflector.ConvertArguments(dataRow, parameterTypes);
var theoryDisplayName = TypeUtility.GetDisplayNameWithArguments(TestCase.TestMethod.Method, DisplayName, convertedDataRow, resolvedTypes);
testRunners.Add(new XunitTestRunner(TestCase, MessageBus, TestClass, ConstructorArguments, methodToRun, convertedDataRow, theoryDisplayName, SkipReason, BeforeAfterAttributes, Aggregator, CancellationTokenSource));
}
}
}
catch (Exception ex)
{
if (!MessageBus.QueueMessage(new TestStarting(TestCase, DisplayName)))
{
CancellationTokenSource.Cancel();
}
else
{
if (!MessageBus.QueueMessage(new TestFailed(TestCase, DisplayName, 0, null, ex.Unwrap())))
{
CancellationTokenSource.Cancel();
}
}
if (!MessageBus.QueueMessage(new TestFinished(TestCase, DisplayName, 0, null)))
{
CancellationTokenSource.Cancel();
}
return(new RunSummary {
Total = 1, Failed = 1
});
}
var runSummary = new RunSummary();
foreach (var testRunner in testRunners)
{
runSummary.Aggregate(await testRunner.RunAsync());
}
var timer = new ExecutionTimer();
var aggregator = new ExceptionAggregator();
// REVIEW: What should be done with these leftover errors?
foreach (var disposable in toDispose)
{
timer.Aggregate(() => aggregator.Run(() => disposable.Dispose()));
}
runSummary.Time += timer.Total;
return(runSummary);
}
/// <inheritdoc />
protected override async Task RunTestsOnMethodAsync(IMessageBus messageBus,
Type classUnderTest,
object[] constructorArguments,
MethodInfo methodUnderTest,
List <BeforeAfterTestAttribute> beforeAfterAttributes,
ExceptionAggregator aggregator,
CancellationTokenSource cancellationTokenSource)
{
var executionTime = 0M;
try
{
var testMethod = Reflector.Wrap(methodUnderTest);
var dataAttributes = testMethod.GetCustomAttributes(typeof(DataAttribute));
foreach (var dataAttribute in dataAttributes)
{
var discovererAttribute = dataAttribute.GetCustomAttributes(typeof(DataDiscovererAttribute)).First();
var args = discovererAttribute.GetConstructorArguments().Cast <string>().ToList();
var discovererType = Reflector.GetType(args[1], args[0]);
var discoverer = ExtensibilityPointFactory.GetDataDiscoverer(discovererType);
foreach (object[] dataRow in discoverer.GetData(dataAttribute, testMethod))
{
var methodToRun = methodUnderTest;
ITypeInfo[] resolvedTypes = null;
if (methodToRun.IsGenericMethodDefinition)
{
resolvedTypes = ResolveGenericTypes(testMethod, dataRow);
methodToRun = methodToRun.MakeGenericMethod(resolvedTypes.Select(t => ((IReflectionTypeInfo)t).Type).ToArray());
}
executionTime +=
await RunTestWithArgumentsAsync(messageBus,
classUnderTest,
constructorArguments,
methodToRun,
dataRow,
GetDisplayNameWithArguments(DisplayName, dataRow, resolvedTypes),
beforeAfterAttributes,
aggregator,
cancellationTokenSource);
if (cancellationTokenSource.IsCancellationRequested)
{
return;
}
}
}
}
catch (Exception ex)
{
if (!messageBus.QueueMessage(new TestStarting(this, DisplayName)))
{
cancellationTokenSource.Cancel();
}
else
{
if (!messageBus.QueueMessage(new TestFailed(this, DisplayName, executionTime, null, ex.Unwrap())))
{
cancellationTokenSource.Cancel();
}
}
if (!messageBus.QueueMessage(new TestFinished(this, DisplayName, executionTime, null)))
{
cancellationTokenSource.Cancel();
}
}
}
