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 static async Task <RunSummary> RunTestInternalAsync(XunitTestRunner runner) { TestContext.InitializeContext(runner.GetTest()); try { return(await runner.RunAsync()); } finally { TestContext.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); } }
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; } }
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 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 static async Task<RunSummary> RunTestInternalAsync(XunitTestRunner runner) { TestContext.InitializeContext(runner.GetTest()); try { return await runner.RunAsync(); } finally { TestContext.FreeContext(); } }