public void Run_AfterLoad_ReturnsRunnableSuite()
{
LoadMockAssembly();
var result = _runner.Run(TestListener.NULL, TestFilter.Empty);
Assert.That(result.Test.IsSuite);
Assert.That(result.Test, Is.TypeOf <TestAssembly>());
Assert.That(result.Test.RunState, Is.EqualTo(RunState.Runnable));
Assert.That(result.Test.TestCaseCount, Is.EqualTo(MockAssembly.Tests));
Assert.That(result.ResultState, Is.EqualTo(ResultState.ChildFailure));
Assert.That(result.PassCount, Is.EqualTo(MockAssembly.Success));
Assert.That(result.FailCount, Is.EqualTo(MockAssembly.ErrorsAndFailures));
Assert.That(result.SkipCount, Is.EqualTo(MockAssembly.Skipped));
Assert.That(result.InconclusiveCount, Is.EqualTo(MockAssembly.Inconclusive));
}
private void RunTests(ITestFilter filter)
{
ITestResult result = runner.Run(this, filter);
new ResultReporter(result, writer).ReportResults();
string resultFile = commandLineOptions.ResultFile;
string resultFormat = commandLineOptions.ResultFormat;
if (resultFile != null || commandLineOptions.ResultFormat != null)
{
if (resultFile == null)
{
resultFile = "TestResult.xml";
}
if (resultFormat == "nunit2")
{
new NUnit2XmlOutputWriter().WriteResultFile(result, resultFile);
}
else
{
new NUnit3XmlOutputWriter().WriteResultFile(result, resultFile);
}
Console.WriteLine();
Console.WriteLine("Results saved as {0}.", resultFile);
}
}
public void Execute(Assembly assembly)
{
try {
Randomizer.InitialSeed = 0;
if (!runner.Load(assembly, new Dictionary <string, string>()))
{
throw new Exception($"No tests found in assembly {AssemblyHelper.GetAssemblyName(assembly).Name}");
}
ITestFilter filter = (ITestFilter)formatter.Deserialize(stream);
AppDomain.CurrentDomain.UnhandledException += TopLevelHandler;
ITestResult result = (ITestResult)runner.Run(this, filter);
formatter.Serialize(stream, new Xamarin.ResultMessage {
TestResult = result
});
AppDomain.CurrentDomain.UnhandledException -= TopLevelHandler;
}
catch (Exception ex)
{
formatter.Serialize(stream, new Xamarin.ExceptionMessage {
Exception = ex
});
throw;
}
}
public int RunTests(TestFilter filter, IDictionary <string, object> runSettings)
{
var startTime = DateTime.UtcNow;
ITestResult result = _runner.Run(this, filter);
ReportResults(result);
#if !PORTABLE
if (_options.ResultOutputSpecifications.Count > 0)
{
var outputManager = new OutputManager(_options.WorkDirectory);
foreach (var spec in _options.ResultOutputSpecifications)
{
outputManager.WriteResultFile(result, spec, runSettings, filter);
}
}
#endif
if (Summary.InvalidTestFixtures > 0)
{
return(INVALID_TEST_FIXTURE);
}
return(Summary.FailureCount + Summary.ErrorCount + Summary.InvalidCount);
}
public int RunTests(TestFilter filter, IDictionary runSettings)
{
var startTime = DateTime.UtcNow;
ITestResult result = _runner.Run(this, filter);
#if SILVERLIGHT
// Silverlight can't display results while the test is running
// so we do it afterwards.
foreach (ITestResult testResult in _results)
{
_textUI.TestFinished(testResult);
}
#endif
ReportResults(result);
#if !SILVERLIGHT && !PORTABLE
if (_options.ResultOutputSpecifications.Count > 0)
{
var outputManager = new OutputManager(_options.WorkDirectory);
foreach (var spec in _options.ResultOutputSpecifications)
{
outputManager.WriteResultFile(result, spec, runSettings, filter);
}
}
#endif
return(Summary.FailureCount + Summary.ErrorCount + Summary.InvalidCount);
}
public ITestResult Execute()
{
IDictionary loadOptions = new System.Collections.Generic.Dictionary <string, string>();
if (!runner.Load(this.testAssembly, loadOptions))
{
AssemblyName assemblyName = AssemblyHelper.GetAssemblyName(this.testAssembly);
throw new Exception(string.Format("No tests found in assembly {0}", assemblyName.Name));
}
return(runner.Run(this.listener, TestFilter.Empty));
}
/// <summary>
/// Run selected tests synchronously or asynchronously, notifying the listener interface as it progresses.
/// </summary>
/// <param name="assemblies">The list of test assembly runners to run.</param>
/// <param name="listener">Interface to receive EventListener notifications.</param>
/// <param name="filter">A test filter used to select tests to be run.</param>
/// <param name="runAsync"><c>true</c> to run tests asynchronously, otherwise <c>false</c> to run synchronously.</param>
/// <param name="results">The <see cref="ITestResult" /> object to add the test results to.</param>
private static void RunTests(IList <ITestAssemblyRunner> assemblies,
ITestListener listener, ITestFilter filter, bool runAsync, ref TestSuiteResult results)
{
filter = ValidateFilter(filter);
Queue <ITestAssemblyRunner> testQueue = new Queue <ITestAssemblyRunner>(assemblies);
// Check each test not ran when first encountered to see if it is ready to be run
while (testQueue.Count > 0)
{
// Run test if not currently running, otherwise queue up to be checked again later
ITestAssemblyRunner test = testQueue.Dequeue();
if (!test.IsTestRunning)
{
if (runAsync)
{
test.RunAsync(listener, filter);
}
else
{
test.Run(listener, filter);
}
}
else
{
// Test not ready to run so re-enqueue
testQueue.Enqueue(test);
}
// Slow down the polling loop to give time for tests to complete
if (runAsync)
{
Thread.Sleep(10);
}
}
// Wait for tests to complete
while (assemblies.Any(test => test.IsTestRunning || !test.IsTestComplete))
// Slow down the polling loop to give time for tests to complete
{
Thread.Sleep(10);
}
// Add individual test runner results to overall result
foreach (ITestAssemblyRunner test in assemblies)
{
if (test.Result != null)
{
results.AddResult(test.Result);
}
}
}
private void RunTests()
{
NUnit.Framework.Api.ITestResult testResult = runner.Run(TestListener.NULL, TestFilter.Empty);
ReportResults(testResult);
string resultFile = commandLineOptions.ResultFile;
if (resultFile != null)
{
XmlTextWriter xmlTextWriter = new XmlTextWriter(resultFile, Encoding.UTF8);
xmlTextWriter.Formatting = Formatting.Indented;
testResult.ToXml(recursive: true).WriteTo(xmlTextWriter);
xmlTextWriter.Close();
}
}
private void RunTests(ITestFilter filter)
{
ITestResult result = runner.Run(this, filter);
ExitCode = result.FailCount > 0 ? 1 : 0;
new ResultReporter(result, writer).ReportResults();
if (commandLineOptions.ResultFile != null)
{
new NUnit2XmlOutputWriter().WriteResultFile(result, commandLineOptions.ResultFile);
Console.WriteLine();
Console.WriteLine("Results saved as {0}.", commandLineOptions.ResultFile);
}
}
private void RunTests()
{
ITestResult result = runner.Run(TestListener.NULL, TestFilter.Empty);
ReportResults(result);
string resultFile = commandLineOptions.ResultFile;
if (resultFile != null)
{
XmlTextWriter resultWriter = new XmlTextWriter(resultFile, System.Text.Encoding.UTF8);
resultWriter.Formatting = Formatting.Indented;
result.ToXml(true).WriteTo(resultWriter);
resultWriter.Close();
}
}
private void RunTests(ITestFilter filter)
{
DateTime startTime = DateTime.Now;
var crashHandler = new UnhandledExceptionEventHandler(TopLevelHandler);
AppDomain.CurrentDomain.UnhandledException += crashHandler;
ITestResult result = runner.Run(this, filter);
new ResultReporter(result, writer).ReportResults();
string resultFile = commandLineOptions.ResultFile;
string resultFormat = commandLineOptions.ResultFormat;
this.Failure = (result.ResultState.Equals(ResultState.Failure) || result.ResultState.Equals(ResultState.Error));
if (resultFile != null || commandLineOptions.ResultFormat != null)
{
if (resultFile == null)
{
resultFile = "TestResult.xml";
}
if (resultFormat == "nunit2")
{
new NUnit2XmlOutputWriter(startTime).WriteResultFile(result, resultFile);
}
else if (resultFormat == "nunit3")
{
new NUnit3XmlOutputWriter(startTime).WriteResultFile(result, resultFile);
}
#if MONO
else if (resultFormat == "xunit")
{
new XunitXmlOutputWriter(startTime).WriteResultFile(result, resultFile);
}
#endif
else
{
throw new Exception("Unknown resultFormat.");
}
Console.WriteLine();
Console.WriteLine("Results saved as {0}.", resultFile);
}
AppDomain.CurrentDomain.UnhandledException -= crashHandler;
}
private ITestResult runTests(string nameSpace, TestFilter filter)
{
IDictionary options = new Hashtable();
if (nameSpace != null)
{
options["LOAD"] = new string[] { nameSpace }
}
;
if (runner.Load(testAssembly, options))
{
return(runner.Run(TestListener.NULL, filter));
}
return(null);
}
private void RunTests(ITestFilter filter)
{
var startTime = DateTime.UtcNow;
ITestResult result = _runner.Run(this, filter);
new ResultReporter(result, _outWriter).ReportResults();
if (_options.ResultOutputSpecifications.Count > 0)
{
var outputManager = new OutputManager(_workDirectory);
foreach (var spec in _options.ResultOutputSpecifications)
{
outputManager.WriteResultFile(result, spec);
}
}
}
private void ExecuteTests()
{
ITestResult result = runner.Run(TestListener.NULL, TestFilter.Empty);
ResultReporter reporter = new ResultReporter(result, writer);
reporter.ReportResults();
ResultSummary summary = reporter.Summary;
this.Total.Text = summary.TestCount.ToString();
this.Failures.Text = summary.FailureCount.ToString();
this.Errors.Text = summary.ErrorCount.ToString();
this.NotRun.Text = summary.NotRunCount.ToString();
this.Passed.Text = summary.PassCount.ToString();
this.Inconclusive.Text = summary.InconclusiveCount.ToString();
this.Notice.Visibility = Visibility.Collapsed;
}
private ITestResult runTests(string nameSpace, TestFilter filter)
{
IDictionary <string, object> options = new Dictionary <string, object>();
if (nameSpace != null)
{
options["LOAD"] = new string[] { nameSpace }
}
;
// No need for the overhead of parallel execution here
options["NumberOfTestWorkers"] = 0;
if (runner.Load(testAssembly, options) != null)
{
return(runner.Run(TestListener.NULL, filter));
}
return(null);
}
private int RunTests(ITestFilter filter)
{
var startTime = DateTime.UtcNow;
ITestResult result = _runner.Run(this, filter);
var reporter = new ResultReporter(result, _outWriter, _options.StopOnError);
reporter.ReportResults();
if (_options.ResultOutputSpecifications.Count > 0)
{
var outputManager = new OutputManager(_workDirectory);
foreach (var spec in _options.ResultOutputSpecifications)
{
outputManager.WriteResultFile(result, spec);
}
}
var summary = reporter.Summary;
return(summary.FailureCount + summary.ErrorCount + summary.InvalidCount);
}
private void RunTests(ITestFilter filter)
{
DateTime startTime = DateTime.Now;
ITestResult result = runner.Run(this, filter);
new ResultReporter(result, writer).ReportResults();
string resultFile = commandLineOptions.ResultFile;
string resultFormat = commandLineOptions.ResultFormat;
if (resultFile != null || commandLineOptions.ResultFormat != null)
{
if (resultFile == null)
{
resultFile = "TestResult.xml";
}
if (resultFormat == "nunit2")
{
new NUnit2XmlOutputWriter(startTime).WriteResultFile(result, resultFile);
/*XslTransform xslt = new XslTransform();
* xslt.Load("XslTransform_2_6_3.xlst");
* xslt.Transform(xPathNav, null, fileStream, null);
* XslTransform transform = new XslTransform();
* transform.Transform(resultFile,"XslTransform.xlst");
* XmlTextWriter myWriter = new XmlTextWriter("result.html",null);*/
}
else
{
new NUnit3XmlOutputWriter(startTime).WriteResultFile(result, resultFile);
}
Console.WriteLine();
Console.WriteLine("Results saved as {0}.", resultFile);
}
}
private void RunTests()
{
NUnit.Framework.Api.ITestResult result = runner.Run(TestListener.NULL, TestFilter.Empty);
ReportResults(result);
}
private static ITestResult RunTests(ITestAssemblyRunner testRunner, Type testsType)
{
var testFilter = new ClassNameFilter(testsType.FullName);
return(testRunner.Run(TestListener.NULL, testFilter));
}
private void RunTests()
{
ITestResult result = runner.Run(TestListener.NULL, TestFilter.Empty);
ReportResults(result);
}
/// <inheritdoc />
public ITestResult Run(ITestListener listener, ITestFilter filter)
{
v_IsTestCompleteOverride = false;
v_IsTestRunningOverride = false;
return(v_Runner.Run(listener, filter));
}