/// <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();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="XunitDiscoveryOptions"/> class.
/// </summary>
/// <param name="configuration">The optional configuration to copy values from.</param>
public XunitDiscoveryOptions(TestAssemblyConfiguration configuration = null)
{
if (configuration != null)
{
DiagnosticMessages = configuration.DiagnosticMessages;
MethodDisplay = configuration.MethodDisplay;
}
}
public static void ConfigurationFileNotFound_ReturnsFalse()
{
var configuration = new TestAssemblyConfiguration();
var result = ConfigReader.Load(configuration, AssemblyFileName, Path.Combine(AssemblyPath, "UnknownFile.txt"));
Assert.False(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="XunitExecutionOptions"/> class.
/// </summary>
/// <param name="configuration">The optional configuration to copy values from.</param>
public XunitExecutionOptions(TestAssemblyConfiguration configuration = null)
{
if (configuration != null)
{
DiagnosticMessages = configuration.DiagnosticMessages;
DisableParallelization = !configuration.ParallelizeTestCollections;
MaxParallelThreads = configuration.MaxParallelThreads;
}
}
AssemblyRunner(AppDomainSupport appDomainSupport,
string assemblyFileName,
string configFileName = null,
bool shadowCopy = true,
string shadowCopyFolder = null)
{
controller = new XunitFrontController(appDomainSupport, assemblyFileName, configFileName, shadowCopy, shadowCopyFolder, diagnosticMessageSink: this);
configuration = ConfigReader.Load(assemblyFileName, configFileName);
}
protected virtual ITestFrameworkExecutionOptions GetFrameworkOptionsForExecution(TestAssemblyConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
return(TestFrameworkOptions.ForExecution(configuration));
}
public static void ConfigurationFileWithMaxThreadsExplicitUnlimited_ReturnsUnlimited()
{
var configuration = new TestAssemblyConfiguration();
var result = ConfigReader.Load(configuration, AssemblyFileName, Path.Combine(AssemblyPath, "ConfigReader_MaxThreadsUnlimited.json"));
Assert.True(result);
Assert.Equal(-1, configuration.MaxParallelThreadsOrDefault);
}
public static void ConfigurationFileWithNegativeThreadValue_ReturnsConfiguredValue(string configFileName)
{
var configuration = new TestAssemblyConfiguration();
var result = ConfigReader.Load(configuration, AssemblyFileName, Path.Combine(AssemblyPath, configFileName));
Assert.True(result);
Assert.Equal(-1, configuration.MaxParallelThreadsOrDefault);
}
public static void ConfigurationFileWithMaxThreadsAsMultiplier_ReturnsMultipliedValue()
{
var configuration = new TestAssemblyConfiguration();
var result = ConfigReader.Load(configuration, AssemblyFileName, Path.Combine(AssemblyPath, "ConfigReader_MaxThreadsMultiplier.json"));
Assert.True(result);
Assert.Equal(Environment.ProcessorCount * 2, configuration.MaxParallelThreadsOrDefault);
}
public static void ConfigurationFileWithZeroThreads_ReturnsProcessorCount(string configFileName)
{
var configuration = new TestAssemblyConfiguration();
var result = ConfigReader.Load(configuration, AssemblyFileName, Path.Combine(AssemblyPath, configFileName));
Assert.True(result);
Assert.Equal(Environment.ProcessorCount, configuration.MaxParallelThreadsOrDefault);
}
public static void SupportInvariantCulture()
{
var configuration = new TestAssemblyConfiguration();
var result = ConfigReader.Load(configuration, AssemblyFileName, Path.Combine(AssemblyPath, "ConfigReader_CultureInvariant.json"));
Assert.True(result);
Assert.Equal(string.Empty, configuration.Culture);
}
public TdNetRunnerHelper(Assembly assembly, ITestListener testListener)
{
this.testListener = testListener;
var assemblyFileName = assembly.GetLocalCodeBase();
configuration = ConfigReader.Load(assemblyFileName);
var diagnosticMessageSink = new DiagnosticMessageSink(testListener, Path.GetFileNameWithoutExtension(assemblyFileName), configuration.DiagnosticMessagesOrDefault);
xunit = new Xunit2(configuration.AppDomainOrDefault, new NullSourceInformationProvider(), assemblyFileName, shadowCopy: false, diagnosticMessageSink: diagnosticMessageSink);
toDispose.Push(xunit);
}
public TdNetRunnerHelper(Assembly assembly, ITestListener testListener)
{
this.testListener = testListener;
var assemblyFileName = assembly.GetLocalCodeBase();
xunit = new Xunit2(new NullSourceInformationProvider(), assemblyFileName);
configuration = ConfigReader.Load(assemblyFileName);
toDispose.Push(xunit);
}
public static void ConfigurationFileWithMaxThreadsExplicitDefault_ReturnsProcessorCount()
{
var configuration = new TestAssemblyConfiguration {
MaxParallelThreads = 2112
};
var result = ConfigReader.Load(configuration, AssemblyFileName, Path.Combine(AssemblyPath, "ConfigReader_MaxThreadsDefault.json"));
Assert.True(result);
Assert.Equal(Environment.ProcessorCount, configuration.MaxParallelThreadsOrDefault);
}
public static void SupportDefaultCulture()
{
var configuration = new TestAssemblyConfiguration {
Culture = "override-me"
};
var result = ConfigReader.Load(configuration, AssemblyFileName, Path.Combine(AssemblyPath, "ConfigReader_CultureDefault.json"));
Assert.True(result);
Assert.Null(configuration.Culture);
}
public TdNetRunnerHelper(Assembly assembly, ITestListener testListener)
{
this.testListener = testListener;
var assemblyFileName = assembly.GetLocalCodeBase();
configuration = ConfigReader.Load(assemblyFileName);
var diagnosticMessageVisitor = new DiagnosticMessageVisitor(testListener, Path.GetFileNameWithoutExtension(assemblyFileName), configuration.DiagnosticMessagesOrDefault);
xunit = new Xunit2(configuration.UseAppDomainOrDefault, new NullSourceInformationProvider(), assemblyFileName, shadowCopy: false, diagnosticMessageSink: diagnosticMessageVisitor);
toDispose.Push(xunit);
}
private static List <ITestCase> GetTestCaseList(XunitFrontController xunit, TestAssemblyConfiguration configuration, HashSet <string> testCaseNameSet)
{
var testCaseList = new List <ITestCase>();
using (var sink = new TestDiscoverySink(testCaseNameSet, testCaseList))
{
xunit.Find(includeSourceInformation: false, messageSink: sink,
discoveryOptions: TestFrameworkOptions.ForDiscovery(configuration));
sink.Finished.WaitOne();
}
return(testCaseList);
}
AssemblyRunner2(AppDomainSupport appDomainSupport,
string assemblyFileName,
TaskCompletionSource <string> tcs,
CancellationToken cancellationToken,
string configFileName = null,
bool shadowCopy = true,
string shadowCopyFolder = null)
{
this.tcs = tcs;
this.cancellationToken = cancellationToken;
this.assemblyFileName = assemblyFileName;
controller = new XunitFrontController(appDomainSupport, assemblyFileName, configFileName, shadowCopy, shadowCopyFolder, diagnosticMessageSink: MessageSinkAdapter.Wrap(this));
configuration = ConfigReader.Load(assemblyFileName, configFileName);
}
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 ITestAssemblyDiscoveryStarting TestAssemblyDiscoveryStarting(bool diagnosticMessages = false, bool appDomain = false)
{
var assembly = new XunitProjectAssembly {
AssemblyFilename = "testAssembly.dll", ConfigFilename = "testAssembly.dll.config", ShadowCopy = true
};
var config = new TestAssemblyConfiguration {
DiagnosticMessages = diagnosticMessages, MethodDisplay = Xunit.TestMethodDisplay.ClassAndMethod, MaxParallelThreads = 42, ParallelizeTestCollections = true
};
var result = Substitute.For <ITestAssemblyDiscoveryStarting, InterfaceProxy <ITestAssemblyDiscoveryStarting> >();
result.AppDomain.Returns(appDomain);
result.Assembly.Returns(assembly);
result.DiscoveryOptions.Returns(TestFrameworkOptions.ForDiscovery(config));
return(result);
}
public static void EmptyConfigurationFile_ReturnsDefaultValues(string configFileName)
{
var configuration = new TestAssemblyConfiguration();
var result = ConfigReader.Load(configuration, AssemblyFileName, Path.Combine(AssemblyPath, configFileName));
Assert.True(result);
Assert.False(configuration.DiagnosticMessagesOrDefault);
Assert.False(configuration.InternalDiagnosticMessagesOrDefault);
Assert.Equal(Environment.ProcessorCount, configuration.MaxParallelThreadsOrDefault);
Assert.Equal(TestMethodDisplay.ClassAndMethod, configuration.MethodDisplayOrDefault);
Assert.Equal(TestMethodDisplayOptions.None, configuration.MethodDisplayOptionsOrDefault);
Assert.False(configuration.ParallelizeAssemblyOrDefault);
Assert.True(configuration.ParallelizeTestCollectionsOrDefault);
Assert.True(configuration.PreEnumerateTheoriesOrDefault);
}
public static void Main(string[] args)
{
string assemblyPath = @"path";
XunitFrontController controller = new XunitFrontController(
assemblyPath);
TestAssemblyConfiguration assemblyConfiguration = new TestAssemblyConfiguration();
ITestFrameworkDiscoveryOptions discoveryOptions = TestFrameworkOptions.ForDiscovery(assemblyConfiguration);
ITestFrameworkExecutionOptions executionOptions = TestFrameworkOptions.ForExecution(assemblyConfiguration);
IMessageSink messageSink = new CustomTestMessageVisitor <ITestMessage>();
Console.WriteLine("Running tests");
controller.RunAll(
messageSink: messageSink,
discoveryOptions: discoveryOptions,
executionOptions: executionOptions);
}
public static ITestAssemblyDiscoveryFinished TestAssemblyDiscoveryFinished(bool diagnosticMessages = false, int toRun = 42, int discovered = 2112)
{
var assembly = new XunitProjectAssembly {
AssemblyFilename = "testAssembly.dll", ConfigFilename = "testAssembly.dll.config"
};
var config = new TestAssemblyConfiguration {
DiagnosticMessages = diagnosticMessages, ShadowCopy = true
};
var result = Substitute.For <ITestAssemblyDiscoveryFinished, InterfaceProxy <ITestAssemblyDiscoveryFinished> >();
result.Assembly.Returns(assembly);
result.DiscoveryOptions.Returns(TestFrameworkOptions.ForDiscovery(config));
result.TestCasesDiscovered.Returns(discovered);
result.TestCasesToRun.Returns(toRun);
return(result);
}
public static void ConfigurationFileWithInvalidValues_FallsBackToDefaultValues(string configFileName)
{
var configuration = new TestAssemblyConfiguration();
var result = ConfigReader.Load(configuration, AssemblyFileName, Path.Combine(AssemblyPath, configFileName));
Assert.True(result);
Assert.False(configuration.DiagnosticMessagesOrDefault);
Assert.False(configuration.InternalDiagnosticMessagesOrDefault);
Assert.Equal(Environment.ProcessorCount, configuration.MaxParallelThreadsOrDefault);
Assert.Equal(TestMethodDisplay.ClassAndMethod, configuration.MethodDisplayOrDefault);
Assert.Equal(TestMethodDisplayOptions.None, configuration.MethodDisplayOptionsOrDefault);
// This value was valid as a sentinel to make sure we were trying to read values from the config file
Assert.True(configuration.ParallelizeAssemblyOrDefault);
Assert.True(configuration.ParallelizeTestCollectionsOrDefault);
Assert.True(configuration.PreEnumerateTheoriesOrDefault);
}
public static void ConfigurationFileWithValidValues_ReturnsConfiguredValues(string configFileName)
{
var configuration = new TestAssemblyConfiguration();
var result = ConfigReader.Load(configuration, AssemblyFileName, Path.Combine(AssemblyPath, configFileName));
Assert.True(result);
Assert.True(configuration.DiagnosticMessagesOrDefault);
Assert.True(configuration.InternalDiagnosticMessagesOrDefault);
Assert.Equal(2112, configuration.MaxParallelThreadsOrDefault);
Assert.Equal(TestMethodDisplay.Method, configuration.MethodDisplayOrDefault);
Assert.Equal(TestMethodDisplayOptions.All, configuration.MethodDisplayOptionsOrDefault);
Assert.True(configuration.ParallelizeAssemblyOrDefault);
Assert.False(configuration.ParallelizeTestCollectionsOrDefault);
Assert.False(configuration.PreEnumerateTheoriesOrDefault);
Assert.Equal(5, configuration.LongRunningTestSecondsOrDefault);
}
public static ITestAssemblyExecutionFinished TestAssemblyExecutionFinished(bool diagnosticMessages = false, int total = 2112, int failed = 42, int skipped = 8, int errors = 6, decimal time = 123.456M)
{
var assembly = new XunitProjectAssembly {
AssemblyFilename = "testAssembly.dll", ConfigFilename = "testAssembly.dll.config"
};
var config = new TestAssemblyConfiguration {
DiagnosticMessages = diagnosticMessages, ShadowCopy = true
};
var summary = new ExecutionSummary {
Total = total, Failed = failed, Skipped = skipped, Errors = errors, Time = time
};
var result = Substitute.For <ITestAssemblyExecutionFinished, InterfaceProxy <ITestAssemblyExecutionFinished> >();
result.Assembly.Returns(assembly);
result.ExecutionOptions.Returns(TestFrameworkOptions.ForExecution(config));
result.ExecutionSummary.Returns(summary);
return(result);
}
//public void Run(string testAssemblyPath)
//{
// if (null != testAssemblyPath && File.Exists(testAssemblyPath)) {
// using (var controller = new XunitFrontController(AppDomainSupport.Denied, testAssemblyPath))
// using (var discoveryVisitor = new DefaultDiscoveryVisitor())
// using (var executionVisitor = new DefaultExecutionVisitor()) {
// controller.Find(false, discoveryVisitor, TestFrameworkOptions.ForDiscovery());
// discoveryVisitor.Finished.WaitOne();
// controller.RunTests(discoveryVisitor.TestCases, executionVisitor, TestFrameworkOptions.ForExecution());
// executionVisitor.Finished.WaitOne();
// }
// }
//}
TestAssemblyConfiguration LoadTestAssemblyConfiguration(string assembly)
{
Type t = Type.GetType("Mono.Runtime");
TestAssemblyConfiguration conf;
try {
conf = ConfigReader.Load(assembly);
} catch (FileNotFoundException) {
conf = new TestAssemblyConfiguration();
}
if (t != null)
{
// TODO: support below
conf.PreEnumerateTheories = true;
conf.ParallelizeTestCollections = false;
conf.AppDomain = AppDomainSupport.Denied;
}
return(conf);
}
/// <summary>
/// Loads the test assembly configuration for the given test assembly.
/// </summary>
/// <param name="configuration">The configuration object to write the values to.</param>
/// <param name="assemblyFileName">The test assembly.</param>
/// <param name="configFileName">The test assembly configuration file.</param>
/// <returns>A flag which indicates whether configuration values were read.</returns>
public static bool Load(
TestAssemblyConfiguration configuration,
string?assemblyFileName,
string?configFileName = null)
{
// JSON configuration takes priority over XML configuration
if (ConfigReader_Json.Load(configuration, assemblyFileName, configFileName))
{
return(true);
}
#if NETFRAMEWORK
if (ConfigReader_Configuration.Load(configuration, assemblyFileName, configFileName))
{
return(true);
}
#endif
return(false);
}
public int Run(string assemblyFileName, bool printXml, XunitFilters filters)
{
var configuration = new TestAssemblyConfiguration()
{
ShadowCopy = false, ParallelizeAssembly = false, ParallelizeTestCollections = false, MaxParallelThreads = 1, PreEnumerateTheories = false
};
var discoveryOptions = TestFrameworkOptions.ForDiscovery(configuration);
var discoverySink = new TestDiscoverySink();
var diagnosticSink = new ConsoleDiagnosticMessageSink();
var testOptions = TestFrameworkOptions.ForExecution(configuration);
var testSink = new TestMessageSink();
var controller = new Xunit2(AppDomainSupport.Denied, new NullSourceInformationProvider(), assemblyFileName, configFileName: null, shadowCopy: false, shadowCopyFolder: null, diagnosticMessageSink: diagnosticSink, verifyTestAssemblyExists: false);
discoveryOptions.SetSynchronousMessageReporting(true);
testOptions.SetSynchronousMessageReporting(true);
Console.WriteLine($"Discovering tests for {assemblyFileName}");
var assembly = Assembly.LoadFrom(assemblyFileName);
var assemblyInfo = new global::Xunit.Sdk.ReflectionAssemblyInfo(assembly);
var discoverer = new ThreadlessXunitDiscoverer(assemblyInfo, new NullSourceInformationProvider(), discoverySink);
discoverer.FindWithoutThreads(includeSourceInformation: false, discoverySink, discoveryOptions);
discoverySink.Finished.WaitOne();
var testCasesToRun = discoverySink.TestCases.Where(filters.Filter).ToList();
Console.WriteLine($"Discovery finished.");
var summarySink = new DelegatingExecutionSummarySink(testSink, () => false, (completed, summary) => { Console.WriteLine($"Tests run: {summary.Total}, Errors: 0, 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.TestPassedEvent += args => { Console.WriteLine($"[PASS] {args.Message.Test.DisplayName}"); };
testSink.Execution.TestSkippedEvent += args => { Console.WriteLine($"[SKIP] {args.Message.Test.DisplayName}"); };
testSink.Execution.TestFailedEvent += args => { Console.WriteLine($"[FAIL] {args.Message.Test.DisplayName}{Environment.NewLine}{ExceptionUtility.CombineMessages(args.Message)}{Environment.NewLine}{ExceptionUtility.CombineStackTraces(args.Message)}"); };
testSink.Execution.TestAssemblyStartingEvent += args => { Console.WriteLine($"Running tests for {args.Message.TestAssembly.Assembly}"); };
testSink.Execution.TestAssemblyFinishedEvent += args => { Console.WriteLine($"Finished {args.Message.TestAssembly.Assembly}{Environment.NewLine}"); };
controller.RunTests(testCasesToRun, resultsSink, testOptions);
var threadpoolPump = typeof(ThreadPool).GetMethod("PumpThreadPool", BindingFlags.NonPublic | BindingFlags.Static);
if (threadpoolPump != null)
{
while (!resultsSink.Finished.WaitOne(0))
{
threadpoolPump.Invoke(this, null);
}
}
else
{
resultsSink.Finished.WaitOne();
}
if (printXml)
{
Console.WriteLine($"STARTRESULTXML");
var resultsXml = new XElement("assemblies");
resultsXml.Add(resultsXmlAssembly);
resultsXml.Save(Console.OpenStandardOutput());
Console.WriteLine();
Console.WriteLine($"ENDRESULTXML");
}
var failed = resultsSink.ExecutionSummary.Failed > 0 || resultsSink.ExecutionSummary.Errors > 0;
return(failed ? 1 : 0);
}
protected virtual XElement ExecuteAssembly(string assemblyFileName, string configFileName, TestAssemblyConfiguration configuration)
{
if (cancel)
return null;
var assemblyElement = CreateAssemblyXElement();
try
{
if (DiagnosticMessages)
configuration.DiagnosticMessages = true;
var discoveryOptions = TestFrameworkOptions.ForDiscovery(configuration);
var executionOptions = TestFrameworkOptions.ForExecution(configuration);
if (maxParallelThreads.HasValue && maxParallelThreads.Value > -1)
executionOptions.SetMaxParallelThreads(maxParallelThreads);
if (parallelizeTestCollections.HasValue)
executionOptions.SetDisableParallelization(!parallelizeTestCollections);
var assemblyDisplayName = Path.GetFileNameWithoutExtension(assemblyFileName);
if (configuration.DiagnosticMessagesOrDefault)
Log.LogMessage(MessageImportance.High, " Discovering: {0} (method display = {1}, parallel test collections = {2}, max threads = {3})",
assemblyDisplayName,
discoveryOptions.GetMethodDisplayOrDefault(),
!executionOptions.GetDisableParallelizationOrDefault(),
executionOptions.GetMaxParallelThreadsOrDefault());
else
Log.LogMessage(MessageImportance.High, " Discovering: {0}", assemblyDisplayName);
var diagnosticMessageVisitor = new DiagnosticMessageVisitor(Log, assemblyDisplayName, configuration.DiagnosticMessagesOrDefault);
using (var controller = CreateFrontController(assemblyFileName, configFileName, diagnosticMessageVisitor))
using (var discoveryVisitor = new TestDiscoveryVisitor())
{
controller.Find(includeSourceInformation: false, discoveryMessageSink: discoveryVisitor, discoveryOptions: discoveryOptions);
discoveryVisitor.Finished.WaitOne();
Log.LogMessage(MessageImportance.High, " Discovered: {0}", assemblyDisplayName);
var filteredTestCases = discoveryVisitor.TestCases.Where(Filters.Filter).ToList();
if (filteredTestCases.Count == 0)
completionMessages.TryAdd(assemblyDisplayName, new ExecutionSummary());
else
{
if (SerializeTestCases)
filteredTestCases = filteredTestCases.Select(controller.Serialize).Select(controller.Deserialize).ToList();
using (var resultsVisitor = CreateVisitor(assemblyFileName, assemblyElement))
{
controller.RunTests(filteredTestCases, resultsVisitor, executionOptions);
resultsVisitor.Finished.WaitOne();
if (resultsVisitor.Failed != 0)
ExitCode = 1;
}
}
}
}
catch (Exception ex)
{
var e = ex;
while (e != null)
{
Log.LogError("{0}: {1}", e.GetType().FullName, e.Message);
foreach (var stackLine in e.StackTrace.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries))
Log.LogError(stackLine);
e = e.InnerException;
}
ExitCode = -1;
}
return assemblyElement;
}
protected override XElement ExecuteAssembly(string assemblyFilename, string configFileName, TestAssemblyConfiguration configuration)
{
ExecuteAssembly_Calls.Add(String.Format("{0}, {1}", assemblyFilename ?? "(null)", configFileName ?? "(null)"));
return(base.ExecuteAssembly(assemblyFilename, configFileName, configuration));
}
public async Task <int> Run(string assemblyFileName, bool printXml, XunitFilters filters)
{
var configuration = new TestAssemblyConfiguration()
{
ShadowCopy = false, ParallelizeAssembly = false, ParallelizeTestCollections = false, MaxParallelThreads = 1, PreEnumerateTheories = false
};
var discoveryOptions = TestFrameworkOptions.ForDiscovery(configuration);
var discoverySink = new TestDiscoverySink();
var diagnosticSink = new ConsoleDiagnosticMessageSink();
var testOptions = TestFrameworkOptions.ForExecution(configuration);
var testSink = new TestMessageSink();
var controller = new Xunit2(AppDomainSupport.Denied, new NullSourceInformationProvider(), assemblyFileName, configFileName: null, shadowCopy: false, shadowCopyFolder: null, diagnosticMessageSink: diagnosticSink, verifyTestAssemblyExists: false);
discoveryOptions.SetSynchronousMessageReporting(true);
testOptions.SetSynchronousMessageReporting(true);
Console.WriteLine($"Discovering: {assemblyFileName} (method display = {discoveryOptions.GetMethodDisplayOrDefault()}, method display options = {discoveryOptions.GetMethodDisplayOptionsOrDefault()})");
var assembly = Assembly.LoadFrom(assemblyFileName);
var assemblyInfo = new global::Xunit.Sdk.ReflectionAssemblyInfo(assembly);
var discoverer = new ThreadlessXunitDiscoverer(assemblyInfo, new NullSourceInformationProvider(), discoverySink);
discoverer.FindWithoutThreads(includeSourceInformation: false, discoverySink, discoveryOptions);
discoverySink.Finished.WaitOne();
var testCasesToRun = discoverySink.TestCases.Where(filters.Filter).ToList();
Console.WriteLine($"Discovered: {assemblyFileName} (found {testCasesToRun.Count} of {discoverySink.TestCases.Count} test cases)");
var summarySink = new DelegatingExecutionSummarySink(testSink, () => false, (completed, summary) => { Console.WriteLine($"{Environment.NewLine}=== TEST EXECUTION SUMMARY ==={Environment.NewLine}Total: {summary.Total}, Errors: 0, Failed: {summary.Failed}, Skipped: {summary.Skipped}, Time: {TimeSpan.FromSeconds((double)summary.Time).TotalSeconds}s{Environment.NewLine}"); });
var resultsXmlAssembly = new XElement("assembly");
var resultsSink = new DelegatingXmlCreationSink(summarySink, resultsXmlAssembly);
if (Environment.GetEnvironmentVariable("XHARNESS_LOG_TEST_START") != null)
{
testSink.Execution.TestStartingEvent += args => { Console.WriteLine($"[STRT] {args.Message.Test.DisplayName}"); };
}
testSink.Execution.TestPassedEvent += args => { Console.WriteLine($"[PASS] {args.Message.Test.DisplayName}"); };
testSink.Execution.TestSkippedEvent += args => { Console.WriteLine($"[SKIP] {args.Message.Test.DisplayName}"); };
testSink.Execution.TestFailedEvent += args => { Console.WriteLine($"[FAIL] {args.Message.Test.DisplayName}{Environment.NewLine}{ExceptionUtility.CombineMessages(args.Message)}{Environment.NewLine}{ExceptionUtility.CombineStackTraces(args.Message)}"); };
testSink.Execution.TestAssemblyStartingEvent += args => { Console.WriteLine($"Starting: {assemblyFileName}"); };
testSink.Execution.TestAssemblyFinishedEvent += args => { Console.WriteLine($"Finished: {assemblyFileName}"); };
controller.RunTests(testCasesToRun, resultsSink, testOptions);
while (!resultsSink.Finished.WaitOne(0))
{
await Task.Delay(1);
}
if (printXml)
{
Console.WriteLine($"STARTRESULTXML");
var resultsXml = new XElement("assemblies");
resultsXml.Add(resultsXmlAssembly);
resultsXml.Save(Console.OpenStandardOutput());
Console.WriteLine();
Console.WriteLine($"ENDRESULTXML");
}
var failed = resultsSink.ExecutionSummary.Failed > 0 || resultsSink.ExecutionSummary.Errors > 0;
return(failed ? 1 : 0);
}
private static List<ITestCase> GetTestCaseList(XunitFrontController xunit, TestAssemblyConfiguration configuration, HashSet<string> testCaseNameSet)
{
var testCaseList = new List<ITestCase>();
using (var sink = new TestDiscoverySink(testCaseNameSet, testCaseList))
{
xunit.Find(includeSourceInformation: false, messageSink: sink,
discoveryOptions: TestFrameworkOptions.ForDiscovery(configuration));
sink.Finished.WaitOne();
}
return testCaseList;
}
