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