private static ITestFrameworkExecutionOptions ConfiguExecutionOptions([NotNull] XunitProjectAssembly assembly, [NotNull] TestRunOptions options)
{
if (assembly == null)
{
throw new ArgumentNullException(nameof(assembly));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
bool stopOnFail = options.StopOnFail;
ITestFrameworkExecutionOptions executionOptions = TestFrameworkOptions.ForExecution(assembly.Configuration);
executionOptions.SetStopOnTestFail(stopOnFail);
int?maxThreadCount = options.MaxParallelThreads;
if (maxThreadCount.HasValue)
{
executionOptions.SetMaxParallelThreads(maxThreadCount);
}
bool?parallelizeTestCollections = options.ParallelizeTestCollections;
if (parallelizeTestCollections.HasValue)
{
executionOptions.SetDisableParallelization(!parallelizeTestCollections.GetValueOrDefault());
}
return(executionOptions);
}
static void Main(string[] args)
{
var nodeIndex = CommandLine.GetInt32("multinode.index");
var assemblyFileName = CommandLine.GetProperty("multinode.test-assembly");
var typeName = CommandLine.GetProperty("multinode.test-class");
var testName = CommandLine.GetProperty("multinode.test-method");
var displayName = testName;
Thread.Sleep(TimeSpan.FromSeconds(10));
using (var controller = new XunitFrontController(assemblyFileName))
{
/* need to pass in just the assembly name to Discovery, not the full path
* i.e. "Akka.Cluster.Tests.MultiNode.dll"
* not "bin/Release/Akka.Cluster.Tests.MultiNode.dll" - this will cause
* the Discovery class to actually not find any indivudal specs to run
*/
var assemblyName = Path.GetFileName(assemblyFileName);
Console.WriteLine("Running specs for {0} [{1}]", assemblyName, assemblyFileName);
using (var discovery = new Discovery(assemblyName, typeName))
{
using (var sink = new Sink(nodeIndex))
{
Thread.Sleep(10000);
try
{
controller.Find(true, discovery, TestFrameworkOptions.ForDiscovery());
discovery.Finished.WaitOne();
controller.RunTests(discovery.TestCases, sink, TestFrameworkOptions.ForExecution());
}
catch (AggregateException ex)
{
var specFail = new SpecFail(nodeIndex, displayName);
specFail.FailureExceptionTypes.Add(ex.GetType().ToString());
specFail.FailureMessages.Add(ex.Message);
specFail.FailureStackTraces.Add(ex.StackTrace);
foreach (var innerEx in ex.Flatten().InnerExceptions)
{
specFail.FailureExceptionTypes.Add(innerEx.GetType().ToString());
specFail.FailureMessages.Add(innerEx.Message);
specFail.FailureStackTraces.Add(innerEx.StackTrace);
}
Console.WriteLine(specFail);
Environment.Exit(1); //signal failure
}
catch (Exception ex)
{
var specFail = new SpecFail(nodeIndex, displayName);
specFail.FailureExceptionTypes.Add(ex.GetType().ToString());
specFail.FailureMessages.Add(ex.Message);
specFail.FailureStackTraces.Add(ex.StackTrace);
Console.WriteLine(specFail);
Environment.Exit(1); //signal failure
}
sink.Finished.WaitOne();
Environment.Exit(sink.Passed ? 0 : 1);
}
}
}
}
public static int RunAll(Assembly assembly)
{
var logger = new ConsoleOutputVisitor();
var xassembly = new ReflectionAssemblyInfo(assembly);
var discoveryOptions = TestFrameworkOptions.ForDiscovery();
discoveryOptions.SetSynchronousMessageReporting(true);
discoveryOptions.SetDiagnosticMessages(true);
var executionOptions = TestFrameworkOptions.ForExecution();
executionOptions.SetSynchronousMessageReporting(true);
executionOptions.SetDiagnosticMessages(true);
executionOptions.SetMaxParallelThreads(MaxThreadCount);
executionOptions.SetDisableParallelization(MaxThreadCount <= 1);
var controller = new XunitFrontController(
xassembly.AssemblyPath,
shadowCopy: false,
diagnosticMessageSink: logger);
controller.RunAll(logger, discoveryOptions, executionOptions);
return(0);
}
public virtual TestRunState Run(IReadOnlyList <ITestCase> testCases = null, TestRunState initialRunState = TestRunState.NoTests)
{
try
{
if (testCases == null)
{
testCases = Discover();
}
var visitor = new ResultVisitor(testListener, testCases.Count)
{
TestRunState = initialRunState
};
toDispose.Push(visitor);
var executionOptions = TestFrameworkOptions.ForExecution(configuration);
xunit.RunTests(testCases, visitor, executionOptions);
visitor.Finished.WaitOne();
return(visitor.TestRunState);
}
catch (Exception ex)
{
testListener.WriteLine("Error during test execution:\r\n" + ex, Category.Error);
return(TestRunState.Error);
}
}
public virtual TestRunState Run(IEnumerable <ITestCase> testCases = null, TestRunState initialRunState = TestRunState.NoTests)
{
try
{
if (testCases != null)
{
testCases = testCases.ToList();
}
var visitor = new ResultVisitor(testListener)
{
TestRunState = initialRunState
};
toDispose.Push(visitor);
var executionOptions = TestFrameworkOptions.ForExecution(configuration);
if (testCases == null)
{
xunit.RunAll(visitor, TestFrameworkOptions.ForDiscovery(configuration), executionOptions);
}
else
{
xunit.RunTests(testCases, visitor, executionOptions);
}
visitor.Finished.WaitOne();
return(visitor.TestRunState);
}
catch (Exception ex)
{
testListener.WriteLine("Error during test execution:\r\n" + ex, Category.Error);
return(TestRunState.Error);
}
}
/// <summary>
/// Execute test cases.
/// </summary>
/// <param name="assembly">Assembly.</param>
/// <param name="testInfos">Test infos.</param>
/// <param name="executionListener">Execution listener.</param>
/// <remarks>It uses xunit execution engine to execute the test cases.</remarks>
public void Execute(string assembly, string[] nameFilter, IRemoteEventListener executionListener)
{
var lookup = new HashSet <string>();
foreach (var testId in nameFilter)
{
lookup.Add(testId);
}
TestAssemblyConfiguration conf = LoadTestAssemblyConfiguration(assembly);
var discoveryOptions = TestFrameworkOptions.ForDiscovery(conf);
var executionOptions = TestFrameworkOptions.ForExecution(conf);
executionOptions.SetSynchronousMessageReporting(true);
// we don't want to run every test in the assembly
// only the tests passed in "testInfos" argument
using (var controller = new XunitFrontController(conf.AppDomainOrDefault, assembly, null, conf.ShadowCopyOrDefault, null, new NullSourceInformationProvider()))
using (var discoveryVisitor = new DefaultDiscoveryVisitor(tc => lookup.Contains(tc.UniqueID)))
using (var executionVisitor = new DefaultExecutionVisitor(executionListener)) {
controller.Find(false, discoveryVisitor, discoveryOptions);
discoveryVisitor.Finished.WaitOne();
controller.RunTests(discoveryVisitor.TestCases, executionVisitor, executionOptions);
executionVisitor.Finished.WaitOne();
}
}
ITestFrameworkExecutionOptions GetExecutionOptions(bool?diagnosticMessages, bool?parallel, int?maxParallelThreads, bool?internalDiagnosticMessages)
{
var executionOptions = TestFrameworkOptions.ForExecution(configuration);
executionOptions.SetSynchronousMessageReporting(true);
if (diagnosticMessages.HasValue)
{
executionOptions.SetDiagnosticMessages(diagnosticMessages);
}
if (internalDiagnosticMessages.HasValue)
{
executionOptions.SetDiagnosticMessages(internalDiagnosticMessages);
}
if (parallel.HasValue)
{
executionOptions.SetDisableParallelization(!parallel.GetValueOrDefault());
}
if (maxParallelThreads.HasValue)
{
executionOptions.SetMaxParallelThreads(maxParallelThreads);
}
return(executionOptions);
}
public WasmRunner(XunitProject project)
{
this.project = project;
var assemblyFileName = "/" + project.Assemblies.First().AssemblyFilename;
testCases = new List <ITestCase> ();
var assembly = Assembly.LoadFrom(assemblyFileName);
var assemblyInfo = new Xunit.Sdk.ReflectionAssemblyInfo(assembly);
var collectionBehaviorAttribute = assemblyInfo.GetCustomAttributes(typeof(CollectionBehaviorAttribute)).SingleOrDefault();
var testAssembly = new TestAssembly(assemblyInfo, null);
var collectionFactory = ExtensibilityPointFactory.GetXunitTestCollectionFactory(this, collectionBehaviorAttribute, testAssembly);
/*
* object res = null;
* res = Activator.CreateInstance (typeof (Xunit.Sdk.MemberDataDiscoverer), true, true);
* Console.WriteLine ("DISC2: " + res);
*/
DiscoveryOptions = TestFrameworkOptions.ForDiscovery(null);
executionOptions = TestFrameworkOptions.ForExecution(null);
discoverer = new Discoverer(assemblyInfo, new NullSourceInformationProvider(), this, DiscoveryOptions, collectionFactory);
executor = new XunitTestFrameworkExecutor(assembly.GetName(), new NullSourceInformationProvider(), this);
}
/// <summary>
/// Execute test cases.
/// </summary>
/// <param name="assembly">Assembly.</param>
/// <param name="testInfos">Test infos.</param>
/// <param name="executionListener">Execution listener.</param>
/// <remarks>It uses xunit execution engine to execute the test cases.</remarks>
public void Execute(string assembly, string data, IXUnitExecutionListener executionListener)
{
XUnitTestInfo[] testInfos = JsonConvert.DeserializeObject <XUnitTestInfo[]> (data);
var lookup = new HashSet <string> ();
foreach (var testInfo in testInfos)
{
lookup.Add(testInfo.Id);
}
// we don't want to run every test in the assembly
// only the tests passed in "testInfos" argument
using (var controller = new XunitFrontController(AppDomainSupport.Denied, assembly, null, false, null, new NullSourceInformationProvider()))
using (var discoveryVisitor = new TestDiscoveryVisitor(tc => lookup.Contains(tc.UniqueID)))
using (var executionVisitor = new TestExecutionVisitor(executionListener)) {
controller.Find(false, discoveryVisitor, TestFrameworkOptions.ForDiscovery());
discoveryVisitor.Finished.WaitOne();
var options = TestFrameworkOptions.ForExecution();
options.SetDisableParallelization(true);
options.SetSynchronousMessageReporting(true);
controller.RunTests(discoveryVisitor.TestCases, executionVisitor, options);
}
}
private ITestFrameworkExecutionOptions GetExecutionOptions()
{
var options = TestFrameworkOptions.ForExecution(configuration);
options.SetSynchronousMessageReporting(true);
return(options);
}
private static SequentialTestAssemblyRunner CreateTestAssemblyRunner(IEnumerable <IXunitTestCase> testCases, TestAssembly testAssembly) =>
new SequentialTestAssemblyRunner(
testAssembly,
testCases,
DiagnosticMessageSink,
ExecutionMessageSink,
TestFrameworkOptions.ForExecution());
void RunTestsInAssembly(List <IDisposable> toDispose, AssemblyRunInfo runInfo)
{
if (cancelled)
{
return;
}
var assemblyFileName = runInfo.AssemblyFileName;
var controller = new XunitFrontController(AppDomainSupport.Denied, assemblyFileName);
lock (toDispose)
toDispose.Add(controller);
var xunitTestCases = runInfo.TestCases.Select(tc => new
{
vm = tc,
tc = tc.TestCase
})
.Where(tc => tc.tc.UniqueID != null)
.ToDictionary(tc => tc.tc, tc => tc.vm);
var executionOptions = TestFrameworkOptions.ForExecution(runInfo.Configuration);
using (var executionVisitor = new TestExecutionVisitor(xunitTestCases, this, executionOptions, () => cancelled, context))
{
controller.RunTests(xunitTestCases.Select(tc => tc.Value.TestCase).ToList(), executionVisitor, executionOptions);
executionVisitor.Finished.WaitOne();
}
}
protected virtual ITestFrameworkExecutionOptions GetFrameworkOptionsForExecution(TestAssemblyConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
return(TestFrameworkOptions.ForExecution(configuration));
}
void RunTestsInAssembly(IRunContext runContext,
IFrameworkHandle frameworkHandle,
LoggerHelper logger,
IMessageSink reporterMessageHandler,
AssemblyRunInfo runInfo)
{
if (cancelled)
{
return;
}
var assembly = new XunitProjectAssembly {
AssemblyFilename = runInfo.AssemblyFileName
};
var assemblyFileName = runInfo.AssemblyFileName;
var assemblyDisplayName = Path.GetFileNameWithoutExtension(assemblyFileName);
var shadowCopy = assembly.Configuration.ShadowCopyOrDefault;
var appDomain = assembly.Configuration.AppDomain ?? AppDomainDefaultBehavior;
if (DisableAppDomainRequestedInRunContext(runContext.RunSettings.SettingsXml))
{
appDomain = AppDomainSupport.Denied;
}
try
{
#if PLATFORM_DOTNET
// For AppX Apps, use the package location
assemblyFileName = Path.Combine(Windows.ApplicationModel.Package.Current.InstalledLocation.Path, Path.GetFileName(assemblyFileName));
#endif
var diagnosticSink = new DiagnosticMessageSink(logger, assemblyDisplayName, runInfo.Configuration.DiagnosticMessagesOrDefault);
using (var controller = new XunitFrontController(appDomain, assemblyFileName: assemblyFileName, configFileName: null, shadowCopy: shadowCopy, diagnosticMessageSink: MessageSinkAdapter.Wrap(diagnosticSink)))
{
var xunitTestCases = runInfo.TestCases.Select(tc => new { vs = tc, xunit = Deserialize(logger, controller, tc) })
.Where(tc => tc.xunit != null)
.ToDictionary(tc => tc.xunit, tc => tc.vs);
var executionOptions = TestFrameworkOptions.ForExecution(runInfo.Configuration);
executionOptions.SetSynchronousMessageReporting(true);
reporterMessageHandler.OnMessage(new TestAssemblyExecutionStarting(assembly, executionOptions));
using (var executionSink = new VsExecutionSink(frameworkHandle, logger, xunitTestCases, executionOptions, () => cancelled))
{
controller.RunTests(xunitTestCases.Keys.ToList(), executionSink, executionOptions);
executionSink.Finished.WaitOne();
reporterMessageHandler.OnMessage(new TestAssemblyExecutionFinished(assembly, executionOptions, executionSink.ExecutionSummary));
}
}
}
catch (Exception ex)
{
logger.LogError("{0}: Catastrophic failure: {1}", assemblyDisplayName, ex);
}
}
public static void SyncMessageBusOption()
{
var executionOptions = TestFrameworkOptions.ForExecution();
executionOptions.SetSynchronousMessageReporting(true);
var runner = TestableTestAssemblyRunner.Create(executionOptions: executionOptions);
var messageBus = runner.CreateMessageBus_Public();
Assert.IsType <SynchronousMessageBus>(messageBus);
}
public static IEnumerable <IMessageSinkMessage> Run(this Xunit2 runner, IEnumerable <ITestCase> testCases)
{
Guard.AgainstNullArgument("runner", runner);
using (var sink = new SpyMessageSink <ITestAssemblyFinished>())
{
runner.RunTests(testCases, sink, TestFrameworkOptions.ForExecution());
sink.Finished.WaitOne();
return(sink.Messages.Select(message => message));
}
}
public static void TestOptions_NonParallel()
{
var options = TestFrameworkOptions.ForExecution();
options.SetDisableParallelization(true);
var runner = TestableXunitTestAssemblyRunner.Create(executionOptions: options);
var result = runner.GetTestFrameworkEnvironment();
Assert.EndsWith("[collection-per-class, non-parallel]", result);
}
public static void TestOptions_MaxThreads()
{
var options = TestFrameworkOptions.ForExecution();
options.SetMaxParallelThreads(3);
var runner = TestableXunitTestAssemblyRunner.Create(executionOptions: options);
var result = runner.GetTestFrameworkEnvironment();
Assert.EndsWith("[collection-per-class, parallel (3 threads)]", result);
}
static void Main(string[] args)
{
var nodeIndex = CommandLine.GetInt32("multinode.index");
var assemblyName = CommandLine.GetProperty("multinode.test-assembly");
var typeName = CommandLine.GetProperty("multinode.test-class");
var testName = CommandLine.GetProperty("multinode.test-method");
var displayName = testName;
Thread.Sleep(TimeSpan.FromSeconds(10));
using (var controller = new XunitFrontController(assemblyName))
{
using (var discovery = new Discovery(assemblyName, typeName))
{
using (var sink = new Sink(nodeIndex))
{
Thread.Sleep(10000);
try
{
controller.Find(true, discovery, TestFrameworkOptions.ForDiscovery());
discovery.Finished.WaitOne();
controller.RunTests(discovery.TestCases, sink, TestFrameworkOptions.ForExecution());
}
catch (AggregateException ex)
{
var specFail = new SpecFail(nodeIndex, displayName);
specFail.FailureExceptionTypes.Add(ex.GetType().ToString());
specFail.FailureMessages.Add(ex.Message);
specFail.FailureStackTraces.Add(ex.StackTrace);
foreach (var innerEx in ex.Flatten().InnerExceptions)
{
specFail.FailureExceptionTypes.Add(innerEx.GetType().ToString());
specFail.FailureMessages.Add(innerEx.Message);
specFail.FailureStackTraces.Add(innerEx.StackTrace);
}
Console.WriteLine(specFail);
Environment.Exit(1); //signal failure
}
catch (Exception ex)
{
var specFail = new SpecFail(nodeIndex, displayName);
specFail.FailureExceptionTypes.Add(ex.GetType().ToString());
specFail.FailureMessages.Add(ex.Message);
specFail.FailureStackTraces.Add(ex.StackTrace);
Console.WriteLine(specFail);
Environment.Exit(1); //signal failure
}
sink.Finished.WaitOne();
Environment.Exit(sink.Passed ? 0 : 1);
}
}
}
}
private static void ExecuteTests(string code, Action <MessageSink> assertions)
{
var assemblyName = TestAssemblyCompiler.Compile(code);
var sink = new MessageSink();
using (var xunit2 = new Xunit2(new NullSourceInformationProvider(), assemblyName, null, false))
{
xunit2.RunAll(sink, TestFrameworkOptions.ForDiscovery(), TestFrameworkOptions.ForExecution());
sink.WaitTillFinished();
assertions(sink);
}
}
void RunTestsInAssembly(IFrameworkHandle frameworkHandle,
List <IDisposable> toDispose,
AssemblyRunInfo runInfo,
Stopwatch stopwatch)
{
if (cancelled)
{
return;
}
var assemblyFileName = runInfo.AssemblyFileName;
var assemblyDisplayName = Path.GetFileNameWithoutExtension(assemblyFileName);
if (runInfo.Configuration.DiagnosticMessagesOrDefault)
{
lock (stopwatch)
frameworkHandle.SendMessage(TestMessageLevel.Informational, String.Format("[xUnit.net {0}] Execution starting: {1} (method display = {2}, parallel test collections = {3}, max threads = {4})",
stopwatch.Elapsed,
assemblyDisplayName,
runInfo.Configuration.MethodDisplayOrDefault,
runInfo.Configuration.ParallelizeTestCollectionsOrDefault,
runInfo.Configuration.MaxParallelThreadsOrDefault));
}
#if WINDOWS_PHONE_APP || WINDOWS_APP
// For AppX Apps, use the package location
assemblyFileName = Path.Combine(Windows.ApplicationModel.Package.Current.InstalledLocation.Path, Path.GetFileName(assemblyFileName));
#endif
var diagnosticMessageVisitor = new DiagnosticMessageVisitor(frameworkHandle, assemblyDisplayName, runInfo.Configuration.DiagnosticMessagesOrDefault, stopwatch);
var controller = new XunitFrontController(assemblyFileName, configFileName: null, shadowCopy: true, diagnosticMessageSink: diagnosticMessageVisitor);
lock (toDispose)
toDispose.Add(controller);
var xunitTestCases = runInfo.TestCases.ToDictionary(tc => controller.Deserialize(tc.GetPropertyValue <string>(SerializedTestCaseProperty, null)));
var executionOptions = TestFrameworkOptions.ForExecution(runInfo.Configuration);
using (var executionVisitor = new VsExecutionVisitor(frameworkHandle, xunitTestCases, executionOptions, () => cancelled))
{
controller.RunTests(xunitTestCases.Keys.ToList(), executionVisitor, executionOptions);
executionVisitor.Finished.WaitOne();
}
if (runInfo.Configuration.DiagnosticMessagesOrDefault)
{
lock (stopwatch)
frameworkHandle.SendMessage(TestMessageLevel.Informational, String.Format("[xUnit.net {0}] Execution finished: {1}", stopwatch.Elapsed, assemblyDisplayName));
}
}
public static void TestOptionsOverrideAttribute()
{
var attribute = Mocks.CollectionBehaviorAttribute(disableTestParallelization: true, maxParallelThreads: 127);
var options = TestFrameworkOptions.ForExecution();
options.SetDisableParallelization(false);
options.SetMaxParallelThreads(3);
var assembly = Mocks.TestAssembly(new[] { attribute });
var runner = TestableXunitTestAssemblyRunner.Create(assembly: assembly, executionOptions: options);
var result = runner.GetTestFrameworkEnvironment();
Assert.EndsWith("[collection-per-class, parallel (3 threads)]", result);
}
public static Queue <IMessageSinkMessage> Run(this Xunit2 runner, Queue <ITestCase> testCases, TestAssemblyConfiguration testAssemblyConfiguration)
{
if (!testCases.Any())
{
return(new Queue <IMessageSinkMessage>());
}
using (var sink = new SpyMessageSink <ITestCollectionFinished>())
{
runner.RunTests(testCases, sink, TestFrameworkOptions.ForExecution(testAssemblyConfiguration));
sink.Finished.Wait();
return(sink.Messages);
}
}
private static void TestAssembly(Assembly assembly)
{
var messageSink = new ConsoleMessageSink();
var assemblyInfo = new ReflectionAssemblyInfo(assembly);
var framework = new XunitTestFramework(messageSink);
var executor = new XunitTestFrameworkExecutor(assembly.GetName(), new NullSourceInformationProvider(), messageSink);
var executionOptions = TestFrameworkOptions.ForExecution();
var discoveryOptions = TestFrameworkOptions.ForDiscovery();
executor.RunAll(messageSink, discoveryOptions, executionOptions);
messageSink.Finished.WaitOne();
}
public static IEnumerable <IMessageSinkMessage> Run(this Xunit2 runner, IEnumerable <ITestCase> testCases)
{
if (!testCases.Any())
{
return(Enumerable.Empty <IMessageSinkMessage>());
}
using (var sink = new SpyMessageSink <ITestCollectionFinished>())
{
runner.RunTests(testCases, sink, TestFrameworkOptions.ForExecution());
sink.Finished.WaitOne();
return(sink.Messages.Select(_ => _));
}
}
public static ITestAssemblyExecutionStarting TestAssemblyExecutionStarting(bool diagnosticMessages = false, string assemblyFilename = null)
{
var assembly = new XunitProjectAssembly {
AssemblyFilename = assemblyFilename ?? "testAssembly.dll", ConfigFilename = "testAssembly.dll.config"
};
var config = new TestAssemblyConfiguration {
DiagnosticMessages = diagnosticMessages, MethodDisplay = Xunit.TestMethodDisplay.ClassAndMethod, MaxParallelThreads = 42, ParallelizeTestCollections = true, ShadowCopy = true
};
var result = Substitute.For <ITestAssemblyExecutionStarting, InterfaceProxy <ITestAssemblyExecutionStarting> >();
result.Assembly.Returns(assembly);
result.ExecutionOptions.Returns(TestFrameworkOptions.ForExecution(config));
return(result);
}
public static int Main(string[] args)
{
var asm = typeof(SingleFileTestRunner).Assembly;
Console.WriteLine("Running assembly:" + asm.FullName);
var diagnosticSink = new ConsoleDiagnosticMessageSink();
var testsFinished = new TaskCompletionSource();
var testSink = new TestMessageSink();
var summarySink = new DelegatingExecutionSummarySink(testSink,
() => false,
(completed, summary) => Console.WriteLine($"Tests run: {summary.Total}, Errors: {summary.Errors}, Failures: {summary.Failed}, Skipped: {summary.Skipped}. Time: {TimeSpan.FromSeconds((double)summary.Time).TotalSeconds}s"));
var resultsXmlAssembly = new XElement("assembly");
var resultsSink = new DelegatingXmlCreationSink(summarySink, resultsXmlAssembly);
testSink.Execution.TestSkippedEvent += args => { Console.WriteLine($"[SKIP] {args.Message.Test.DisplayName}"); };
testSink.Execution.TestFailedEvent += args => { Console.WriteLine($"[FAIL] {args.Message.Test.DisplayName}{Environment.NewLine}{Xunit.ExceptionUtility.CombineMessages(args.Message)}{Environment.NewLine}{Xunit.ExceptionUtility.CombineStackTraces(args.Message)}"); };
testSink.Execution.TestAssemblyFinishedEvent += args =>
{
Console.WriteLine($"Finished {args.Message.TestAssembly.Assembly}{Environment.NewLine}");
testsFinished.SetResult();
};
var xunitTestFx = new SingleFileTestRunner(diagnosticSink);
var asmInfo = Reflector.Wrap(asm);
var asmName = asm.GetName();
var discoverySink = new TestDiscoverySink();
var discoverer = xunitTestFx.CreateDiscoverer(asmInfo);
discoverer.Find(false, discoverySink, TestFrameworkOptions.ForDiscovery());
discoverySink.Finished.WaitOne();
XunitFilters filters = new XunitFilters();
filters.ExcludedTraits.Add("category", new List <string> {
"failing"
});
var filteredTestCases = discoverySink.TestCases.Where(filters.Filter).ToList();
var executor = xunitTestFx.CreateExecutor(asmName);
executor.RunTests(filteredTestCases, resultsSink, TestFrameworkOptions.ForExecution());
resultsSink.Finished.WaitOne();
var failed = resultsSink.ExecutionSummary.Failed > 0 || resultsSink.ExecutionSummary.Errors > 0;
return(failed ? 1 : 0);
}
void RunTestsInAssembly(List <IDisposable> toDispose, AssemblyRunInfo runInfo)
{
if (cancelled)
{
return;
}
var assemblyFileName = runInfo.AssemblyFileName;
var longRunningSeconds = runInfo.Configuration.LongRunningTestSecondsOrDefault;
var controller = new XunitFrontController(AppDomainSupport.Denied, assemblyFileName);
lock (toDispose)
toDispose.Add(controller);
var xunitTestCases = runInfo.TestCases.Select(tc => new { vm = tc, tc = tc.TestCase })
.Where(tc => tc.tc.UniqueID != null)
.ToDictionary(tc => tc.tc, tc => tc.vm);
var executionOptions = TestFrameworkOptions.ForExecution(runInfo.Configuration);
var diagSink = new DiagnosticMessageSink(d => context.Post(_ => OnDiagnosticMessage?.Invoke(d), null), runInfo.AssemblyFileName, executionOptions.GetDiagnosticMessagesOrDefault());
var deviceExecSink = new DeviceExecutionSink(xunitTestCases, this, context);
IExecutionSink resultsSink = new DelegatingExecutionSummarySink(deviceExecSink, () => cancelled);
if (longRunningSeconds > 0)
{
resultsSink = new DelegatingLongRunningTestDetectionSink(resultsSink, TimeSpan.FromSeconds(longRunningSeconds), diagSink);
}
var assm = new XunitProjectAssembly()
{
AssemblyFilename = runInfo.AssemblyFileName
};
deviceExecSink.OnMessage(new TestAssemblyExecutionStarting(assm, executionOptions));
controller.RunTests(xunitTestCases.Select(tc => tc.Value.TestCase).ToList(), resultsSink, executionOptions);
resultsSink.Finished.WaitOne();
deviceExecSink.OnMessage(new TestAssemblyExecutionFinished(assm, executionOptions, resultsSink.ExecutionSummary));
}
public static async void NonParallel()
{
var passing = Mocks.XunitTestCase <ClassUnderTest>("Passing");
var other = Mocks.XunitTestCase <ClassUnderTest>("Other");
var options = TestFrameworkOptions.ForExecution();
options.SetDisableParallelization(true);
var runner = TestableXunitTestAssemblyRunner.Create(testCases: new[] { passing, other }, executionOptions: options);
await runner.RunAsync();
var threadIDs = runner.TestCasesRun.Select(x => x.Item1).ToList();
Assert.Equal(threadIDs[0], threadIDs[1]);
}
public static TestableTestAssemblyRunner Create(IMessageSink messageSink = null,
RunSummary result = null,
ITestCase[] testCases = null,
ITestFrameworkExecutionOptions executionOptions = null,
bool cancelInRunTestCollectionAsync = false)
{
return(new TestableTestAssemblyRunner(
Mocks.TestAssembly(Assembly.GetExecutingAssembly()),
testCases ?? new[] { Substitute.For <ITestCase>() }, // Need at least one so it calls RunTestCollectionAsync
messageSink ?? SpyMessageSink.Create(),
executionOptions ?? TestFrameworkOptions.ForExecution(),
result ?? new RunSummary(),
cancelInRunTestCollectionAsync
));
}
