protected override async Task<RunSummary> RunTestAsync()
{
var test = new XunitTest(TestCase, DisplayName);
var aggregator = new ExceptionAggregator(Aggregator);
var runner = new XunitTestRunner(test, MessageBus, TestClass, ConstructorArguments, TestMethod, TestMethodArguments, SkipReason, BeforeAfterAttributes, aggregator, CancellationTokenSource);
return await KuduXunitTestRunnerUtils.RunTestAsync(runner, MessageBus, aggregator);
}
protected override async Task <RunSummary> RunTestAsync()
{
var test = new XunitTest(TestCase, DisplayName);
var aggregator = new ExceptionAggregator(Aggregator);
var runner = new XunitTestRunner(test, MessageBus, TestClass, ConstructorArguments, TestMethod, TestMethodArguments, SkipReason, BeforeAfterAttributes, aggregator, CancellationTokenSource);
return(await KuduXunitTestRunnerUtils.RunTestAsync(runner, MessageBus, aggregator));
}
private async Task<RunSummary> RunTestAsync(XunitTestRunner runner)
{
var disableRetry = ((KuduXunitTheoryTestCase)TestCase).DisableRetry;
if (!disableRetry)
{
var value = ConfigurationManager.AppSettings["DisableRetry"];
disableRetry = string.IsNullOrEmpty(value) || bool.Parse(value);
}
return await KuduXunitTestRunnerUtils.RunTestAsync(runner, MessageBus, Aggregator, disableRetry);
}
private static async Task <RunSummary> RunTestAsyncCore(XunitTestRunner runner,
IMessageBus messageBus,
ExceptionAggregator aggregator,
bool disableRetry)
{
try
{
DelayedMessageBus delayedMessageBus = null;
RunSummary summary = null;
// First run
if (!disableRetry)
{
// This is really the only tricky bit: we need to capture and delay messages (since those will
// contain run status) until we know we've decided to accept the final result;
delayedMessageBus = new DelayedMessageBus(messageBus);
runner.SetMessageBus(delayedMessageBus);
summary = await RunTestInternalAsync(runner);
// if succeeded
if (summary.Failed == 0 || aggregator.HasExceptions)
{
delayedMessageBus.Flush(false);
return(summary);
}
}
// Final run
runner.SetMessageBus(new KuduTraceMessageBus(messageBus));
summary = await RunTestInternalAsync(runner);
// flush delay messages
if (delayedMessageBus != null)
{
delayedMessageBus.Flush(summary.Failed == 0 && !aggregator.HasExceptions);
}
return(summary);
}
catch (Exception ex)
{
// this is catastrophic
messageBus.QueueMessage(new TestFailed(runner.GetTest(), 0, null, ex));
return(new RunSummary {
Failed = 1, Total = 1
});
}
finally
{
// set to original
runner.SetMessageBus(messageBus);
}
}
private async Task <RunSummary> RunTestAsync(XunitTestRunner runner)
{
var disableRetry = ((KuduXunitTheoryTestCase)TestCase).DisableRetry;
if (!disableRetry)
{
var value = ConfigurationManager.AppSettings["DisableRetry"];
disableRetry = string.IsNullOrEmpty(value) || bool.Parse(value);
}
return(await KuduXunitTestRunnerUtils.RunTestAsync(runner, MessageBus, Aggregator, disableRetry));
}
private static async Task <RunSummary> RunTestInternalAsync(XunitTestRunner runner)
{
TestTracer.InitializeContext();
try
{
return(await runner.RunAsync());
}
finally
{
TestTracer.FreeContext();
}
}
private static async Task<RunSummary> RunTestAsyncCore(XunitTestRunner runner,
IMessageBus messageBus,
ExceptionAggregator aggregator,
bool disableRetry)
{
try
{
DelayedMessageBus delayedMessageBus = null;
RunSummary summary = null;
// First run
if (!disableRetry)
{
// This is really the only tricky bit: we need to capture and delay messages (since those will
// contain run status) until we know we've decided to accept the final result;
delayedMessageBus = new DelayedMessageBus(messageBus);
runner.SetMessageBus(delayedMessageBus);
summary = await RunTestInternalAsync(runner);
// if succeeded
if (summary.Failed == 0 || aggregator.HasExceptions)
{
delayedMessageBus.Flush(false);
return summary;
}
}
// Final run
runner.SetMessageBus(new KuduTraceMessageBus(messageBus));
summary = await RunTestInternalAsync(runner);
// flush delay messages
if (delayedMessageBus != null)
{
delayedMessageBus.Flush(summary.Failed == 0 && !aggregator.HasExceptions);
}
return summary;
}
catch (Exception ex)
{
// this is catastrophic
messageBus.QueueMessage(new TestFailed(runner.GetTest(), 0, null, ex));
return new RunSummary { Failed = 1, Total = 1 };
}
finally
{
// set to original
runner.SetMessageBus(messageBus);
}
}
public static Task<RunSummary> RunTestAsync(XunitTestRunner runner,
IMessageBus messageBus,
ExceptionAggregator aggregator)
{
// fork non-SynchronizationContext thread
var result = Task.Factory.StartNew(
() => RunTestAsyncCore(runner, messageBus, aggregator).Result,
new CancellationToken(),
TaskCreationOptions.None,
TaskScheduler.Default).Result;
return Task.FromResult(result);
}
private IEnumerator RunTestsInClass(Type classToTest)
{
var allTests = XunitTestRunner.GetIteratorOverAllTests(classToTest, delegate {
// setup before each test
Log.instance = new LogForXunitTestRunnerInUnity();
});
foreach (var test in allTests)
{
yield return(StartTest(test));
}
}
protected override async Task<RunSummary> RunTestAsync()
{
var test = new XunitTest(TestCase, DisplayName);
var aggregator = new ExceptionAggregator(Aggregator);
var disableRetry = ((KuduXunitTestCase)TestCase).DisableRetry;
if (!disableRetry)
{
var value = ConfigurationManager.AppSettings["DisableRetry"];
disableRetry = string.IsNullOrEmpty(value) || bool.Parse(value);
}
var runner = new XunitTestRunner(test, MessageBus, TestClass, ConstructorArguments, TestMethod, TestMethodArguments, SkipReason, BeforeAfterAttributes, aggregator, CancellationTokenSource);
return await KuduXunitTestRunnerUtils.RunTestAsync(runner, MessageBus, aggregator, disableRetry);
}
public static Task <RunSummary> RunTestAsync(XunitTestRunner runner,
IMessageBus messageBus,
ExceptionAggregator aggregator)
{
// fork non-SynchronizationContext thread
var result = Task.Factory.StartNew(
() => RunTestAsyncCore(runner, messageBus, aggregator).Result,
new CancellationToken(),
TaskCreationOptions.None,
TaskScheduler.Default).Result;
return(Task.FromResult(result));
}
private static async Task<RunSummary> RunTestInternalAsync(XunitTestRunner runner)
{
TestContext.InitializeContext(runner.GetTest());
try
{
return await runner.RunAsync();
}
finally
{
TestContext.FreeContext();
// reset FileSystem mockup
FileSystemHelpers.Instance = null;
}
}
private static async Task <RunSummary> RunTestInternalAsync(XunitTestRunner runner)
{
TestContext.InitializeContext(runner.GetTest());
try
{
return(await runner.RunAsync());
}
finally
{
TestContext.FreeContext();
// reset FileSystem mockup
FileSystemHelpers.Instance = null;
}
}
protected override async Task <RunSummary> RunTestAsync()
{
var test = new XunitTest(TestCase, DisplayName);
var aggregator = new ExceptionAggregator(Aggregator);
var disableRetry = ((KuduXunitTestCase)TestCase).DisableRetry;
if (!disableRetry)
{
var value = ConfigurationManager.AppSettings["DisableRetry"];
disableRetry = string.IsNullOrEmpty(value) || bool.Parse(value);
}
var runner = new XunitTestRunner(test, MessageBus, TestClass, ConstructorArguments, TestMethod, TestMethodArguments, SkipReason, BeforeAfterAttributes, aggregator, CancellationTokenSource);
return(await KuduXunitTestRunnerUtils.RunTestAsync(runner, MessageBus, aggregator, disableRetry));
}
private async Task ExecuteTestMethod(MethodInfo runtimeMethod, RunSummary runSummary, IEnumerable <IApplicationAttribute> applicationAttributes, object[] dataRow)
{
foreach (var applicationAttribute in applicationAttributes)
{
Application application = null;
Window mainWindow = null;
WindowFixture fixture = null;
try
{
application = applicationAttribute.ProvideApplication(runtimeMethod);
application.WaitWhileBusy();
mainWindow = null;
if (!string.IsNullOrEmpty(applicationAttribute.Window))
{
mainWindow = application.GetWindow(applicationAttribute.Window);
}
else
{
mainWindow = application.GetWindows().FirstOrDefault();
}
if (mainWindow == null)
{
throw new Exception("Could not locate main window " + applicationAttribute.Window);
}
fixture = new WindowFixture(application, mainWindow);
ITypeInfo[] resolvedTypes = null;
var methodToRun = runtimeMethod;
if (methodToRun.IsGenericMethodDefinition)
{
resolvedTypes = TestCase.TestMethod.Method.ResolveGenericTypes(dataRow);
methodToRun = methodToRun.MakeGenericMethod(resolvedTypes.Select(t => ((IReflectionTypeInfo)t).Type).ToArray());
}
List <object> parameterList = new List <object>();
var parameters = methodToRun.GetParameters().ToArray();
object initializerReturn = null;
int dataRowIndex = 0;
for (int i = 0; i < parameters.Length; i++)
{
var parameter = parameters[i];
var attributes = parameter.GetCustomAttributes(true);
if (parameter.ParameterType == typeof(Window))
{
parameterList.Add(mainWindow);
}
else if (parameter.ParameterType == typeof(IWindowFixture))
{
parameterList.Add(fixture);
}
else if (attributes.Any(a => a is GenerateAttribute))
{
var generateAttribute = (GenerateAttribute)attributes.First(a => a is GenerateAttribute);
InitializeCustomAttribute(generateAttribute, runtimeMethod, parameter);
var constraintName = generateAttribute.ConstraintName ?? parameter.Name;
var min = generateAttribute.Min;
var max = generateAttribute.Max;
var value = fixture.Data.Generate(parameter.ParameterType, constraintName, new { min, max });
parameterList.Add(value);
}
else if (attributes.Any(a => a is LocateAttribute))
{
var locateAttribute = (LocateAttribute)attributes.First(a => a is LocateAttribute);
InitializeCustomAttribute(locateAttribute, runtimeMethod, parameter);
var value = locateAttribute.Value;
if (value == null)
{
value = fixture.Data.Generate(new SimpleFixture.DataRequest(null,
fixture.Data,
parameter.ParameterType,
parameter.Name,
false,
null,
null));
}
parameterList.Add(value);
}
else if (attributes.Any(a => a is FreezeAttribute))
{
var freeze = (FreezeAttribute)attributes.FirstOrDefault(a => a is FreezeAttribute);
InitializeCustomAttribute(freeze, runtimeMethod, parameter);
var value = freeze.Value;
if (value == null)
{
var constraintName = freeze.ConstraintName ?? parameter.Name;
var min = freeze.Min;
var max = freeze.Max;
value = fixture.Data.Generate(parameter.ParameterType, constraintName, new { min, max });
}
parameterList.Add(value);
object lastObject = parameterList.Last();
var closedFreezeMethod =
FreezeMethod.MakeGenericMethod(lastObject.GetType());
closedFreezeMethod.Invoke(null, new object[] { fixture.Data, value, freeze.For });
}
else if (initializerReturn != null && parameter.ParameterType == initializerReturn.GetType())
{
parameterList.Add(initializerReturn);
initializerReturn = null;
}
else if (dataRowIndex < dataRow.Length)
{
var dataValue = dataRow[dataRowIndex];
dataRowIndex++;
parameterList.Add(dataValue);
}
else
{
var value = fixture.Data.Generate(parameter.ParameterType, parameter.Name);
parameterList.Add(value);
}
}
var convertedDataRow = Reflector.ConvertArguments(parameterList.ToArray(), parameters.Select(p => p.ParameterType).ToArray());
var theoryDisplayName =
TestCase.TestMethod.Method.GetDisplayNameWithArguments(DisplayName + " " + applicationAttribute.Application,
dataRow,
resolvedTypes);
var test = new XunitTest(TestCase, theoryDisplayName);
var skipReason = SkipReason;
XunitTestRunner testRunner = CreateTestRunner(test, MessageBus, TestClass, ConstructorArguments, methodToRun, convertedDataRow, skipReason, BeforeAfterAttributes, Aggregator, CancellationTokenSource);
runSummary.Aggregate(await testRunner.RunAsync());
}
catch (Exception exp)
{
Aggregator.Add(exp);
}
finally
{
var timer = new ExecutionTimer();
timer.Aggregate(() => DisposeOfData(application, mainWindow, fixture, dataRow));
runSummary.Time += timer.Total;
}
}
}
private async Task<RunSummary> RunTestAsync(XunitTestRunner runner)
{
var disableRetry = ((KuduXunitTheoryTestCase)TestCase).DisableRetry;
return await KuduXunitTestRunnerUtils.RunTestAsync(runner, MessageBus, Aggregator, disableRetry);
}
private static async Task<RunSummary> RunTestInternalAsync(XunitTestRunner runner)
{
TestContext.InitializeContext(runner.GetTest());
try
{
return await runner.RunAsync();
}
finally
{
TestContext.FreeContext();
}
}
public static ITest GetTest(this XunitTestRunner runner)
{
var prop = typeof(TestRunner <IXunitTestCase>).GetProperty("Test", BindingFlags.Instance | BindingFlags.GetProperty | BindingFlags.NonPublic | BindingFlags.Public);
return((ITest)prop.GetValue(runner));
}
public static async Task <RunSummary> RunTestAsync(XunitTestRunner runner,
IMessageBus messageBus,
ExceptionAggregator aggregator,
bool disableRetry)
{
// defense in depth to avoid forever lock
bool acquired = await _semaphore.WaitAsync(TimeSpan.FromHours(2));
try
{
DelayedMessageBus delayedMessageBus = null;
RunSummary summary = null;
if (!acquired)
{
throw new TimeoutException("Wait for thread to run the test timeout!");
}
// First run
if (!disableRetry)
{
// This is really the only tricky bit: we need to capture and delay messages (since those will
// contain run status) until we know we've decided to accept the final result;
delayedMessageBus = new DelayedMessageBus(messageBus);
runner.SetMessageBus(delayedMessageBus);
summary = await RunTestInternalAsync(runner);
// if succeeded
if (summary.Failed == 0 || aggregator.HasExceptions)
{
delayedMessageBus.Flush(false);
return(summary);
}
}
// Final run
runner.SetMessageBus(new KuduTraceMessageBus(messageBus));
summary = await RunTestInternalAsync(runner);
// flush delay messages
if (delayedMessageBus != null)
{
delayedMessageBus.Flush(summary.Failed == 0 && !aggregator.HasExceptions);
}
return(summary);
}
catch (Exception ex)
{
// this is catastrophic
messageBus.QueueMessage(new TestFailed(runner.GetTest(), 0, null, ex));
return(new RunSummary {
Failed = 1, Total = 1
});
}
finally
{
if (acquired)
{
_semaphore.Release();
}
// set to original
runner.SetMessageBus(messageBus);
}
}
private async Task <RunSummary> RunTestAsync(XunitTestRunner runner)
{
var disableRetry = ((KuduXunitTheoryTestCase)TestCase).DisableRetry;
return(await KuduXunitTestRunnerUtils.RunTestAsync(runner, MessageBus, Aggregator, disableRetry));
}
private async Task <RunSummary> RunTestAsync(XunitTestRunner runner)
{
return(await KuduXunitTestRunnerUtils.RunTestAsync(runner, MessageBus, Aggregator));
}
private async Task ExecuteTestMethod(MethodInfo runtimeMethod, RunSummary runSummary, IEnumerable <WebDriverAttribute> driverAttributes, object[] dataRow)
{
foreach (var driverAttribute in driverAttributes)
{
foreach (var driver in driverAttribute.GetDrivers(runtimeMethod))
{
Fixture newFixture = null;
object initializerReturn = null;
ITypeInfo[] resolvedTypes = null;
var methodToRun = runtimeMethod;
if (methodToRun.IsGenericMethodDefinition)
{
resolvedTypes = TestCase.TestMethod.Method.ResolveGenericTypes(dataRow);
methodToRun = methodToRun.MakeGenericMethod(resolvedTypes.Select(t => ((IReflectionTypeInfo)t).Type).ToArray());
}
List <object> parameterList = new List <object>();
var parameters = methodToRun.GetParameters().ToArray();
try
{
newFixture = FixtureCreationAttribute.GetNewFixture(driver, runtimeMethod);
var initializeDataAttributes = ReflectionHelper.GetAttributes <FixtureInitializationAttribute>(runtimeMethod);
foreach (var initializeDataAttribute in initializeDataAttributes)
{
if (initializeDataAttribute is IMethodInfoAware)
{
#if DNX
var property = initializeDataAttribute.GetType().GetRuntimeProperty("Method");
property.SetValue(initializeDataAttribute, runtimeMethod);
#else
((IMethodInfoAware)initializeDataAttribute).Method = runtimeMethod;
#endif
}
initializeDataAttribute.Initialize(newFixture.Data);
}
var initializeAttribute = ReflectionHelper.GetAttribute <IFixtureInitializationAttribute>(runtimeMethod);
if (initializeAttribute != null)
{
initializerReturn = initializeAttribute.Initialize(runtimeMethod, newFixture);
}
int dataRowIndex = 0;
for (int i = 0; i < parameters.Length; i++)
{
var parameter = parameters[i];
var attributes = parameter.GetCustomAttributes(true);
if (parameter.ParameterType == typeof(IWebDriver))
{
parameterList.Add(driver);
}
else if (parameter.ParameterType == typeof(Fixture))
{
parameterList.Add(newFixture);
}
else if (attributes.Any(a => a is GenerateAttribute))
{
var generateAttribute = (GenerateAttribute)attributes.First(a => a is GenerateAttribute);
InitializeCustomAttribute(generateAttribute, runtimeMethod, parameter);
var constraintName = generateAttribute.ConstraintName ?? parameter.Name;
var min = generateAttribute.Min;
var max = generateAttribute.Max;
var value = newFixture.Data.Generate(parameter.ParameterType, constraintName, new { min, max });
parameterList.Add(value);
}
else if (attributes.Any(a => a is LocateAttribute))
{
var locateAttribute = (LocateAttribute)attributes.First(a => a is LocateAttribute);
InitializeCustomAttribute(locateAttribute, runtimeMethod, parameter);
var value = locateAttribute.Value;
if (value == null)
{
value = newFixture.Data.Generate(new SimpleFixture.DataRequest(null,
newFixture.Data,
parameter.ParameterType,
parameter.Name,
false,
null,
null));
}
parameterList.Add(value);
}
else if (attributes.Any(a => a is FreezeAttribute))
{
var freeze = (FreezeAttribute)attributes.FirstOrDefault(a => a is FreezeAttribute);
InitializeCustomAttribute(freeze, runtimeMethod, parameter);
var value = freeze.Value;
if (value == null)
{
var constraintName = freeze.ConstraintName ?? parameter.Name;
var min = freeze.Min;
var max = freeze.Max;
value = newFixture.Data.Generate(parameter.ParameterType, constraintName, new { min, max });
}
parameterList.Add(value);
object lastObject = parameterList.Last();
var closedFreezeMethod =
FreezeMethod.MakeGenericMethod(lastObject.GetType());
closedFreezeMethod.Invoke(null, new object[] { newFixture.Data, value, freeze.For });
}
else if (initializerReturn != null && parameter.ParameterType == initializerReturn.GetType())
{
parameterList.Add(initializerReturn);
initializerReturn = null;
}
else if (dataRowIndex < dataRow.Length)
{
var dataValue = dataRow[dataRowIndex];
dataRowIndex++;
parameterList.Add(dataValue);
}
else
{
var value = newFixture.Data.Generate(parameter.ParameterType, parameter.Name);
parameterList.Add(value);
}
}
}
catch (Exception exp)
{
Aggregator.Add(exp);
}
var convertedDataRow = Reflector.ConvertArguments(parameterList.ToArray(), parameters.Select(p => p.ParameterType).ToArray());
var theoryDisplayName =
TestCase.TestMethod.Method.GetDisplayNameWithArguments(DisplayName + " " + GetDriverName(driver),
dataRow,
resolvedTypes);
var test = new XunitTest(TestCase, theoryDisplayName);
var skipReason = SkipReason;
XunitTestRunner testRunner = CreateTestRunner(test, MessageBus, TestClass, ConstructorArguments, methodToRun, convertedDataRow, skipReason, BeforeAfterAttributes, Aggregator, CancellationTokenSource);
runSummary.Aggregate(await testRunner.RunAsync());
var timer = new ExecutionTimer();
timer.Aggregate(() => DisposeOfData(driverAttribute, driver, newFixture, dataRow));
runSummary.Time += timer.Total;
}
}
}
public static async Task<RunSummary> RunTestAsync(XunitTestRunner runner,
IMessageBus messageBus,
ExceptionAggregator aggregator,
bool disableRetry)
{
// defense in depth to avoid forever lock
bool acquired = await _semaphore.WaitAsync(TimeSpan.FromHours(2));
try
{
DelayedMessageBus delayedMessageBus = null;
RunSummary summary = null;
if (!acquired)
{
throw new TimeoutException("Wait for thread to run the test timeout!");
}
// First run
if (!disableRetry)
{
// This is really the only tricky bit: we need to capture and delay messages (since those will
// contain run status) until we know we've decided to accept the final result;
delayedMessageBus = new DelayedMessageBus(messageBus);
runner.SetMessageBus(delayedMessageBus);
summary = await RunTestInternalAsync(runner);
// if succeeded
if (summary.Failed == 0 || aggregator.HasExceptions)
{
delayedMessageBus.Flush(false);
return summary;
}
}
// Final run
runner.SetMessageBus(new KuduTraceMessageBus(messageBus));
summary = await RunTestInternalAsync(runner);
// flush delay messages
if (delayedMessageBus != null)
{
delayedMessageBus.Flush(summary.Failed == 0 && !aggregator.HasExceptions);
}
return summary;
}
catch (Exception ex)
{
// this is catastrophic
messageBus.QueueMessage(new TestFailed(runner.GetTest(), 0, null, ex));
return new RunSummary { Failed = 1, Total = 1 };
}
finally
{
if (acquired)
{
_semaphore.Release();
}
// set to original
runner.SetMessageBus(messageBus);
}
}
public static void SetMessageBus(this XunitTestRunner runner, IMessageBus messageBus)
{
var prop = typeof(TestRunner <IXunitTestCase>).GetProperty("MessageBus", BindingFlags.Instance | BindingFlags.SetProperty | BindingFlags.NonPublic | BindingFlags.Public);
prop.SetValue(runner, messageBus);
}
private async Task<RunSummary> RunTestAsync(XunitTestRunner runner)
{
return await KuduXunitTestRunnerUtils.RunTestAsync(runner, MessageBus, Aggregator);
}
