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