private static SimpleNameFilter MakeTestFilter(IEnumerable<TestCase> ptestCases)
{
var filter = new SimpleNameFilter();
foreach (TestCase testCase in ptestCases)
{
filter.Add(testCase.FullyQualifiedName);
}
return filter;
}
private static SimpleNameFilter MakeTestFilter(IEnumerable <TestCase> ptestCases)
{
var filter = new SimpleNameFilter();
foreach (TestCase testCase in ptestCases)
{
filter.Add(testCase.FullyQualifiedName);
}
return(filter);
}
internal static ITestFilter UpdateFilter(ITestFilter filter)
{
if (ExcludeTestNames?.Length == 0)
{
return(filter);
}
var excludeTestNamesFilter = new SimpleNameFilter(ExcludeTestNames);
return(new AndFilter(filter, new NotFilter(excludeTestNamesFilter)));
}
public void ExplicitTestSuiteMatchesWhenSelectedDirectly()
{
NUnit.Core.TestSuite mockTest = (NUnit.Core.TestSuite)TestFinder.Find("MockTestFixture", testSuite, true);
mockTest.RunState = RunState.Explicit;
SimpleNameFilter filter = new SimpleNameFilter("NUnit.Tests.Assemblies.MockTestFixture");
Assert.AreEqual(true, filter.Pass(mock3), "test case");
Assert.AreEqual(true, filter.Pass(mockTest), "middle suite");
Assert.AreEqual(true, filter.Pass(testSuite), "test suite");
}
public void SingleNameMatch()
{
string fullName = "NUnit.Tests.Assemblies.MockTestFixture.MockTest3";
Assert.AreEqual(fullName, mock3.TestName.FullName);
SimpleNameFilter filter = new SimpleNameFilter(fullName);
Assert.IsTrue(filter.Pass(mock3), "Name Filter did not pass test case");
Assert.AreEqual("NUnit.Tests.Assemblies.MockTestFixture", ((TestSuite)testSuite.Tests[0]).TestName.FullName);
Assert.IsTrue(filter.Pass((TestSuite)testSuite.Tests[0]), "Name Filter did not pass test suite");
}
/// <summary>
/// Runs the requested test and return result XML.
/// </summary>
/// <param name="testName"></param>
/// <returns>Result XML document</returns>
private string RunTest(string testName, bool explicitRun)
{
// Execute the give test.
SimpleNameFilter testFilter = new SimpleNameFilter();
testFilter.Add(testName);
TestSuite testSuite = new TestBuilder().Build(assemblyName, true);
//TestResult result = testSuite.Run(this, testFilter);
TestResult result = null;
Queue <ITest> testQueue = new Queue <ITest>();
testQueue.Enqueue(testSuite);
while (testQueue.Count > 0)
{
ITest test = testQueue.Dequeue();
if (test.Tests != null)
{
foreach (ITest childTest in test.Tests)
{
testQueue.Enqueue(childTest);
}
}
else
{
if (test.TestName.FullName.Equals(testName))
{
if (!explicitRun && test.RunState == RunState.Explicit)
{
result = new TestResult(test.TestName);
}
else
{
result = ((Test)test).Run(this, null);
}
}
}
}
// Trace error stack trace.
if (result.StackTrace != null && result.StackTrace.Length > 0)
{
Trace.TraceError(result.StackTrace);
}
// Serialize result to XML.
StringBuilder builder = new StringBuilder();
new XmlResultWriter(new StringWriter(builder)).SaveTestResult(result);
return(builder.ToString());
}
public void MultipleNameMatch()
{
Test mock1 = TestFinder.Find("MockTest1", testSuite, true);
SimpleNameFilter filter = new SimpleNameFilter();
filter.Add("NUnit.Tests.Assemblies.MockTestFixture.MockTest3");
filter.Add("NUnit.Tests.Assemblies.MockTestFixture.MockTest1");
Assert.IsTrue(filter.Pass(mock3), "Name Filter did not pass test case");
Assert.IsTrue(filter.Pass(mock1), "Name Filter did not pass test case");
Assert.IsTrue(filter.Pass((TestSuite)testSuite.Tests[0]), "Name Filter did not pass test suite");
}
private bool CreateTestFilter(HostedOptions options, out TestFilter testFilter)
{
testFilter = TestFilter.Empty;
SimpleNameFilter simpleNameFilter = new SimpleNameFilter();
if (testFilter is NotFilter)
{
((NotFilter)testFilter).TopLevel = true;
}
return(true);
}
public void SimpleNameFilter_AddNames()
{
var filter = new SimpleNameFilter();
filter.Add(dummyName);
filter.Add(anotherName);
Assert.False(filter.IsEmpty);
Assert.That(filter.Match(dummyFixture));
Assert.That(filter.Match(anotherFixture));
Assert.False(filter.Match(yetAnotherFixture));
}
public void MultipleSuiteNameMatch()
{
testSuite.Add(TestBuilder.MakeFixture(typeof(OneTestCase)));
NUnit.Core.TestSuite mockTestFixture = (NUnit.Core.TestSuite)TestFinder.Find("MockTestFixture", testSuite, true);
NUnit.Core.TestSuite oneTestCaseFixture = (NUnit.Core.TestSuite)TestFinder.Find("OneTestCase", testSuite, true);
SimpleNameFilter filter = new SimpleNameFilter("NUnit.Tests.Assemblies.MockTestFixture,NUnit.Tests.Singletons.OneTestCase");
Assert.IsTrue(filter.Pass(mock3), "Name Filter did not pass test case");
Assert.IsTrue(filter.Pass(mockTestFixture), "Fixture did not pass test case");
Assert.IsTrue(filter.Pass(oneTestCaseFixture), "Fixture did not pass test case");
Assert.IsTrue(filter.Pass(testSuite), "Suite did not pass test case");
}
private static TestFilter FromXml(XmlNode xmlNode)
{
switch (xmlNode.Name)
{
case "filter":
case "and":
var andFilter = new AndFilter();
foreach (XmlNode childNode in xmlNode.ChildNodes)
{
andFilter.Add(FromXml(childNode));
}
return(andFilter);
case "or":
var orFilter = new OrFilter();
foreach (System.Xml.XmlNode childNode in xmlNode.ChildNodes)
{
orFilter.Add(FromXml(childNode));
}
return(orFilter);
case "not":
return(new NotFilter(FromXml(xmlNode.FirstChild)));
case "id":
var idFilter = new IdFilter();
foreach (string id in xmlNode.InnerText.Split(COMMA))
{
idFilter.Add(int.Parse(id));
}
return(idFilter);
case "tests":
var testFilter = new SimpleNameFilter();
foreach (XmlNode childNode in xmlNode.SelectNodes("test"))
{
testFilter.Add(childNode.InnerText);
}
return(testFilter);
case "cat":
var catFilter = new CategoryFilter();
foreach (string cat in xmlNode.InnerText.Split(COMMA))
{
catFilter.AddCategory(cat);
}
return(catFilter);
default:
throw new ArgumentException("Invalid filter element: " + xmlNode.Name, "xmlNode");
}
}
private void DoTests()
{
var currentOut = Console.Out;
TestPackage testPackage = new TestPackage(_testAssemblyLocation);
_remoteTestRunner.Load(testPackage);
TestExecutionContext.CurrentContext.TestPackage.Settings.Add("StopOnError", true);
string[] tofilter = _testsToRun;
TestFilter filter = new SimpleNameFilter(tofilter);
//TestResult testResult = _remoteTestRunner.Run(new NullListener(), filter, false, LoggingThreshold.Off);
TestResult testResult = _remoteTestRunner.Run(new NullListener(), TestFilter.Empty, false, LoggingThreshold.Off);
ExitCode = testResult.IsSuccess ? 0 : 1;
Console.SetOut(currentOut);
}
public static TestFilter FromXml(string xmlText)
{
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(xmlText);
XmlNode firstChild = xmlDocument.FirstChild;
if (firstChild.Name != "filter")
{
throw new Exception("Expected filter element at top level");
}
TestFilter testFilter = Empty;
bool flag = true;
XmlNodeList xmlNodeList = firstChild.SelectNodes("tests/test");
XmlNodeList xmlNodeList2 = firstChild.SelectNodes("include/category");
XmlNodeList xmlNodeList3 = firstChild.SelectNodes("exclude/category");
if (xmlNodeList.Count > 0)
{
SimpleNameFilter simpleNameFilter = new SimpleNameFilter();
foreach (XmlNode item in firstChild.SelectNodes("tests/test"))
{
simpleNameFilter.Add(item.InnerText);
}
testFilter = simpleNameFilter;
flag = false;
}
if (xmlNodeList2.Count > 0)
{
XmlNode xmlNode2 = xmlNodeList2[0];
TestFilter filter = new CategoryExpression(xmlNode2.InnerText).Filter;
testFilter = ((!flag) ? new AndFilter(testFilter, filter) : filter);
flag = false;
}
if (xmlNodeList3.Count > 0)
{
CategoryFilter categoryFilter = new CategoryFilter();
foreach (XmlNode item2 in xmlNodeList3)
{
categoryFilter.AddCategory(item2.InnerText);
}
TestFilter testFilter2 = new NotFilter(categoryFilter);
testFilter = ((!flag) ? new AndFilter(testFilter, testFilter2) : testFilter2);
flag = false;
}
return(testFilter);
}
public void RunSpecsForBrokenClass()
{
CoreExtensions.Host.InitializeService();
var pathToTestLibrary = Assembly.GetExecutingAssembly().Location;
var testPackage = new TestPackage(pathToTestLibrary)
{
BasePath = Path.GetDirectoryName(pathToTestLibrary)
};
var builder = new TestSuiteBuilder();
var suite = builder.Build(testPackage);
var filter = new SimpleNameFilter("Examples.BrokenClassSpec");
var result = suite.Run(new NullListener(), filter);
var failedTests = result.FindFailedTests();
Assert.IsTrue(failedTests.All(ft => ft.Message.StartsWith("System.Exception")), "At least one failed spec reported an assertion error when it should have reported an exception.");
}
public void RunGenericFixtureWithFilterForOneTestMethod()
{
GenericTestCounters.ResetCounters();
Type fixtureType = typeof(GenericFixtureWithThreeAttributes <>);
MethodInfo testMethod = fixtureType.GetMethod("Success");
Test suite = _suiteBuilder.BuildFrom(fixtureType);
TestFilter filter = new SimpleNameFilter(
testMethod.ReflectedType.FullName + "." + testMethod.Name);
TestResult testResult = suite.Run(NullListener.NULL, filter);
Assert.That(testResult.IsSuccess, "All tests are successful.");
Assert.That(GenericTestCounters.Test.Value, Is.EqualTo(3), "Executed 3 tests");
Assert.That(GenericTestCounters.SetUp.Value, Is.EqualTo(3), "Execute SetUp 3 times");
Assert.That(GenericTestCounters.TearDown.Value, Is.EqualTo(3), "Execute TearDown 3 times");
}
protected ITestFilter ConstructFilter()
{
var categories = (from ListItem item in cblCategories.Items
where item.Selected
select item.Value).ToArray();
var methodNames = (from ListItem item in cblMethods.Items
where item.Selected
select item.Value).ToArray();
if (!categories.Any() && !methodNames.Any())
{
return(TestFilter.Empty);
}
var categoryFilter = new CategoryFilter(categories);
var methodFilter = new SimpleNameFilter(methodNames);
return(new OrFilter(categoryFilter, methodFilter));
}
void ChainTestNameFilter(string[] testNames, ref ITestFilter filter)
{
if (testNames == null || testNames.Length == 0)
{
Log.Info(LogTag, " none");
return;
}
;
foreach (string name in testNames)
{
if (String.IsNullOrEmpty(name))
{
continue;
}
Log.Info(LogTag, $" {name}");
}
var excludeTestNamesFilter = new SimpleNameFilter(testNames);
filter = new AndFilter(filter, new NotFilter(excludeTestNamesFilter));
}
/// <summary>
/// Runs the requested test and return result XML.
/// </summary>
/// <param name="testName"></param>
/// <returns>Result XML document</returns>
private string RunTest(string testName)
{
// Execute the give test.
SimpleNameFilter testFilter = new SimpleNameFilter();
testFilter.Add(testName);
TestSuite testSuite = new TestBuilder().Build(assemblyName, true);
TestResult result = testSuite.Run(this, testFilter);
// Trace error stack trace.
if (result.StackTrace != null && result.StackTrace.Length > 0)
{
Trace.TraceError(result.StackTrace);
}
// Serialize result to XML.
StringBuilder builder = new StringBuilder();
new XmlResultWriter(new StringWriter(builder)).SaveTestResult(result);
return(builder.ToString());
}
private object RunTest(string id)
{
var invalid = new { text = "Please select a valid test", status = "info" };
if (String.IsNullOrWhiteSpace(id))
{
return new { message = invalid }
}
;
var test = tests.FirstOrDefault(t => t.TestName.FullName.Equals(id));
if (test == null)
{
return new { message = invalid }
}
;
var simpleNameFilter = new SimpleNameFilter(id);
return(RunTests(simpleNameFilter));
}
public UnitTestResult[] RunTests(string[] tests, UnitTestRunner.ITestRunnerCallback testRunnerEventListener)
{
List <String> assemblies = GetAssemblies();
TestSuite suite = PrepareTestSuite(assemblies);
ITestFilter filter = TestFilter.Empty;
if (tests != null && tests.Any())
{
filter = new SimpleNameFilter(tests);
}
testRunnerEventListener.RunStarted(suite.TestName.FullName, suite.TestCount);
NUnit.Core.TestResult result = ExecuteTestSuite(suite,
testRunnerEventListener,
filter);
UpdateTestResults(result);
testRunnerEventListener.RunFinished();
return(testList.ToArray());
}
public void RunTests(string[] tests, UnitTestRunner.ITestRunnerCallback testRunnerEventListener)
{
List <String> assemblies = GetAssemblies();
TestSuite suite = PrepareTestSuite(assemblies);
ITestFilter filter = TestFilter.Empty;
if (tests != null && tests.Any())
{
filter = new SimpleNameFilter(tests);
}
if (testRunnerEventListener != null)
{
testRunnerEventListener.RunStarted(suite.TestName.FullName, suite.TestCount);
}
ExecuteTestSuite(suite, testRunnerEventListener, filter);
if (testRunnerEventListener != null)
{
testRunnerEventListener.RunFinished();
}
}
public int Execute(ConsoleOptions options)
{
XmlTextReader transformReader = GetTransformReader(options);
if (transformReader == null)
{
return(FILE_NOT_FOUND);
}
TextWriter outWriter = Console.Out;
bool redirectOutput = options.output != null && options.output != string.Empty;
if (redirectOutput)
{
StreamWriter outStreamWriter = new StreamWriter(options.output);
outStreamWriter.AutoFlush = true;
outWriter = outStreamWriter;
}
TextWriter errorWriter = Console.Error;
bool redirectError = options.err != null && options.err != string.Empty;
if (redirectError)
{
StreamWriter errorStreamWriter = new StreamWriter(options.err);
errorStreamWriter.AutoFlush = true;
errorWriter = errorStreamWriter;
}
TestRunner testRunner = MakeRunnerFromCommandLine(options);
try
{
if (testRunner.Test == null)
{
testRunner.Unload();
Console.Error.WriteLine("Unable to locate fixture {0}", options.fixture);
return(FIXTURE_NOT_FOUND);
}
EventCollector collector = new EventCollector(options, outWriter, errorWriter);
TestFilter testFilter = TestFilter.Empty;
if (options.run != null && options.run != string.Empty)
{
Console.WriteLine("Selected test: " + options.run);
testFilter = new SimpleNameFilter(options.run);
}
if (options.include != null && options.include != string.Empty)
{
Console.WriteLine("Included categories: " + options.include);
TestFilter includeFilter = new CategoryExpression(options.include).Filter;
if (testFilter.IsEmpty)
{
testFilter = includeFilter;
}
else
{
testFilter = new AndFilter(testFilter, includeFilter);
}
}
if (options.exclude != null && options.exclude != string.Empty)
{
Console.WriteLine("Excluded categories: " + options.exclude);
TestFilter excludeFilter = new NotFilter(new CategoryExpression(options.exclude).Filter);
if (testFilter.IsEmpty)
{
testFilter = excludeFilter;
}
else if (testFilter is AndFilter)
{
((AndFilter)testFilter).Add(excludeFilter);
}
else
{
testFilter = new AndFilter(testFilter, excludeFilter);
}
}
TestResult result = null;
string savedDirectory = Environment.CurrentDirectory;
TextWriter savedOut = Console.Out;
TextWriter savedError = Console.Error;
try
{
result = testRunner.Run(collector, testFilter);
}
finally
{
outWriter.Flush();
errorWriter.Flush();
if (redirectOutput)
{
outWriter.Close();
}
if (redirectError)
{
errorWriter.Close();
}
Environment.CurrentDirectory = savedDirectory;
Console.SetOut(savedOut);
Console.SetError(savedError);
}
Console.WriteLine();
if (result != null)
{
string xmlOutput = CreateXmlOutput(result);
if (options.xmlConsole)
{
Console.WriteLine(xmlOutput);
}
else
{
try
{
//CreateSummaryDocument(xmlOutput, transformReader );
XmlResultTransform xform = new XmlResultTransform(transformReader);
xform.Transform(new StringReader(xmlOutput), Console.Out);
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}", ex.Message);
return(TRANSFORM_ERROR);
}
}
// Write xml output here
string xmlResultFile = options.xml == null || options.xml == string.Empty
? "TestResult.xml" : options.xml;
using (StreamWriter writer = new StreamWriter(xmlResultFile))
{
writer.Write(xmlOutput);
}
}
//if ( testRunner != null )
// testRunner.Unload();
if (collector.HasExceptions)
{
collector.WriteExceptions();
return(UNEXPECTED_ERROR);
}
if (!result.IsFailure)
{
return(OK);
}
ResultSummarizer summ = new ResultSummarizer(result);
return(summ.FailureCount);
}
finally
{
testRunner.Unload();
}
}
public static void Run(string loc, string[] args)
{
MainArgs ma = MainArgs.ValueOf(args);
string excludes = ma.Get("exclude", null);
string includes = ma.Get("include", null);
string outfile = ma.Get("out", "TestResult.xml");
CoreExtensions.Host.InitializeService();
TestSuiteBuilder builder = new TestSuiteBuilder();
TestPackage testPackage = new TestPackage(loc);
RemoteTestRunner remoteTestRunner = new RemoteTestRunner();
remoteTestRunner.Load(testPackage);
TestSuite suite = builder.Build(testPackage);
TestSuite root = suite.Tests[0] as TestSuite;
List <TestFixture> fixtures = new List <TestFixture>();
ScanFixtures(root, fixtures);
Console.WriteLine("--------------- {0} TextFixtures --------------- \n", fixtures.Count);
//TestName testName = ((TestMethod) ((TestFixture) test.Tests[0]).Tests[0]).MethodName;
ITestFilter filter = null;
bool hasInclude = !string.IsNullOrEmpty(includes);
bool hasExclude = !string.IsNullOrEmpty(excludes);
if (hasInclude)
{
if (hasExclude)
{
// incldue+exclude; exclude first
filter =
new AndFilter(new ITestFilter[]
{ new NotFilter(new CategoryFilter(excludes.Split(','))), new SimpleNameFilter(includes.Split(',')), });
}
else
{
// include
filter = new SimpleNameFilter(includes.Split(','));
}
}
else // no include
{
if (hasExclude)
{
// Only exclude
filter = new NotFilter(new CategoryFilter(excludes.Split(',')));
}
else
{
// none
filter = new TrueFilter();
}
}
int succCnt = 0, failCnt = 0, errorCnt = 0, assertCnt = 0;
TestResult tr = new TestResult(new TestName());
RunEventListener eventLsn = new RunEventListener();
foreach (TestFixture tf in fixtures)
{
TestResult result = tf.Run(eventLsn, filter);
FixtureResult fr = null;
if (result.Results != null)
{
fr = new FixtureResult(result);
succCnt += fr.succCnt;
failCnt += fr.failCnt;
errorCnt += fr.errorCnt;
assertCnt += fr.assertCnt;
Console.WriteLine(" Done: " + fr.ToString());
}
else
{
Console.WriteLine(" Done: no result.");
}
tr.AddResult(result);
}
if (failCnt + errorCnt == 0)
{
Console.WriteLine(
@"=========================================
Test Success! Cases: {0}, asserts: {1}
=========================================",
succCnt, assertCnt);
}
else
{
Console.WriteLine(
@"=================================================================================
Test with errors: Cases: {0}, asserts: {4}, Succ: {1}, fail:{2}, error: {3}
=================================================================================",
succCnt + errorCnt + failCnt, succCnt, failCnt, errorCnt, assertCnt);
}
XmlResultWriter w = new XmlResultWriter(outfile);
w.SaveTestResult(tr);
Console.WriteLine("Result save to: {0}", outfile);
}
public int Execute(ExtendedConsoleOptions options)
{
XmlTextReader transformReader = GetTransformReader(options);
if (transformReader == null)
{
return(3);
}
TextWriter outWriter = Console.Out;
if (options.isOut)
{
StreamWriter outStreamWriter = new StreamWriter(options.output);
outStreamWriter.AutoFlush = true;
outWriter = outStreamWriter;
}
TextWriter errorWriter = Console.Error;
if (options.isErr)
{
StreamWriter errorStreamWriter = new StreamWriter(options.err);
errorStreamWriter.AutoFlush = true;
errorWriter = errorStreamWriter;
}
TextWriter testResultWriter = null;
if (options.IsResults)
{
testResultWriter = new StreamWriter(options.results, false, Encoding.UTF8);
((StreamWriter)testResultWriter).AutoFlush = true;
}
TestRunner testRunner = MakeRunnerFromCommandLine(options);
try
{
if (testRunner.Test == null)
{
testRunner.Unload();
Console.Error.WriteLine("Unable to locate fixture {0}", options.fixture);
return(2);
}
EventCollector collector = new EventCollector(options, outWriter, errorWriter, testResultWriter);
TestFilter catFilter = TestFilter.Empty;
if (options.HasInclude)
{
Console.WriteLine("Included categories: " + options.include);
catFilter = new CategoryFilter(options.IncludedCategories);
}
if (options.HasExclude)
{
Console.WriteLine("Excluded categories: " + options.exclude);
TestFilter excludeFilter = new NotFilter(new CategoryFilter(options.ExcludedCategories));
catFilter = AndFilter(catFilter, excludeFilter);
}
if (options.HasNamespaceFilter)
{
Console.WriteLine("Namespace filter: " + options.namespaceFilter);
TestFilter namespaceFilter = GetNamespaceFilter(testRunner, options.namespaceFilter);
catFilter = AndFilter(catFilter, namespaceFilter);
}
if (options.HasTestMethodName || options.IsFixture)
{
SimpleNameFilter nameFilter = new SimpleNameFilter();
if (options.HasTestMethodName)
{
nameFilter.Add(options.testMethodName);
}
else
{
nameFilter.Add(options.fixture);
}
catFilter = AndFilter(catFilter, nameFilter);
}
TestResult result = null;
string savedDirectory = Environment.CurrentDirectory;
TextWriter savedOut = Console.Out;
TextWriter savedError = Console.Error;
try
{
result = testRunner.Run(collector, catFilter);
}
finally
{
outWriter.Flush();
errorWriter.Flush();
if (options.isOut)
{
outWriter.Close();
}
if (options.isErr)
{
errorWriter.Close();
}
if (options.IsResults)
{
testResultWriter.Close();
}
Environment.CurrentDirectory = savedDirectory;
Console.SetOut(savedOut);
Console.SetError(savedError);
}
Console.WriteLine();
string xmlOutput = CreateXmlOutput(result);
if (options.xmlConsole)
{
Console.WriteLine(xmlOutput);
}
else
{
try
{
//CreateSummaryDocument(xmlOutput, transformReader );
XmlResultTransform xform = new XmlResultTransform(transformReader);
xform.Transform(new StringReader(xmlOutput), Console.Out);
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}", ex.Message);
return(3);
}
}
// Write xml output here
string xmlResultFile = options.IsXml ? options.xml : "TestResult.xml";
using (StreamWriter writer = new StreamWriter(xmlResultFile))
{
writer.Write(xmlOutput);
}
//if ( testRunner != null )
// testRunner.Unload();
if (collector.HasExceptions)
{
collector.WriteExceptions();
return(2);
}
return(result.IsFailure ? 1 : 0);
}
finally
{
testRunner.Unload();
}
}
internal static bool CreateTestFilter(ConsoleOptions options, out TestFilter testFilter)
{
testFilter = TestFilter.Empty;
SimpleNameFilter nameFilter = new SimpleNameFilter();
if (options.run != null && options.run != string.Empty)
{
Console.WriteLine("Selected test(s): " + options.run);
foreach (string name in TestNameParser.Parse(options.run))
{
nameFilter.Add(name);
}
testFilter = nameFilter;
}
if (options.runlist != null && options.runlist != string.Empty)
{
Console.WriteLine("Run list: " + options.runlist);
try
{
using (StreamReader rdr = new StreamReader(options.runlist))
{
// NOTE: We can't use rdr.EndOfStream because it's
// not present in .NET 1.x.
string line = rdr.ReadLine();
while (line != null && line.Length > 0)
{
if (line[0] != '#')
{
nameFilter.Add(line);
}
line = rdr.ReadLine();
}
}
}
catch (Exception e)
{
if (e is FileNotFoundException || e is DirectoryNotFoundException)
{
Console.WriteLine("Unable to locate file: " + options.runlist);
return(false);
}
throw;
}
testFilter = nameFilter;
}
if (!string.IsNullOrEmpty(options.include))
{
TestFilter includeFilter = new CategoryExpression(options.include).Filter;
Console.WriteLine("Included categories: " + includeFilter);
if (testFilter.IsEmpty)
{
testFilter = includeFilter;
}
else
{
testFilter = new AndFilter(testFilter, includeFilter);
}
}
if (!string.IsNullOrEmpty(options.exclude))
{
TestFilter excludeFilter = new NotFilter(new CategoryExpression(options.exclude).Filter);
Console.WriteLine("Excluded categories: " + excludeFilter);
if (testFilter.IsEmpty)
{
testFilter = excludeFilter;
}
else if (testFilter is AndFilter)
{
((AndFilter)testFilter).Add(excludeFilter);
}
else
{
testFilter = new AndFilter(testFilter, excludeFilter);
}
}
if (testFilter is NotFilter)
{
((NotFilter)testFilter).TopLevel = true;
}
return(true);
}
static void Main(string[] args)
{
try
{
CoreExtensions.Host.InitializeService();
string assemblyName = "";
if (args.Length == 2)
{
assemblyName = args[1];
}
else
{
Console.WriteLine("usage: VisualNunitRunner.exe [run|list|serve] file");
return;
}
if (args.Length == 2 && args[0] == "run")
{
// Run tests according to console input.
ConsoleTraceListener consoleListener = new ConsoleTraceListener();
Trace.Listeners.Add(consoleListener);
ConsoleTestRunListener runnerListener = new ConsoleTestRunListener();
SimpleNameFilter testFilter = new SimpleNameFilter();
testFilter.Add(Console.ReadLine());
TestSuite testSuite = new TestBuilder().Build(assemblyName, true);
TestResult result = testSuite.Run(runnerListener, testFilter);
if (result.StackTrace != null && result.StackTrace.Length > 0)
{
Trace.TraceError(result.StackTrace);
}
Console.WriteLine("beginning-of-test-result-xml");
StringBuilder builder = new StringBuilder();
new XmlResultWriter(new StringWriter(builder)).SaveTestResult(result);
Console.WriteLine(builder.ToString());
}
else if (args.Length == 2 && args[0] == "list")
{
// List tests to console output.
ConsoleTraceListener consoleListener = new ConsoleTraceListener();
Trace.Listeners.Add(consoleListener);
TestSuite testSuite = new TestBuilder().Build(assemblyName, true);
Queue <ITest> testQueue = new Queue <ITest>();
testQueue.Enqueue(testSuite);
while (testQueue.Count > 0)
{
ITest test = testQueue.Dequeue();
if (test.Tests != null)
{
foreach (ITest childTest in test.Tests)
{
testQueue.Enqueue(childTest);
}
}
else
{
Console.WriteLine(test.TestName.FullName);
}
}
}
else if (args.Length == 2 && args[0] == "serve")
{
// Run in service mode to serve visual studio via named pipes.
RunnerServer runnerServer = new RunnerServer(assemblyName);
while (runnerServer.IsAlive)
{
Thread.Sleep(10);
}
System.Environment.Exit(0);
}
}
catch (Exception e)
{
Trace.TraceError("VisualNunitRunner failed: " + e);
}
}
ITestFilter GetFilters()
{
var simpleNameFilter = new SimpleNameFilter(filters.ToArray());
return(simpleNameFilter);
}
public int Execute(ExtendedConsoleOptions options)
{
TextWriter outWriter = Console.Out;
bool redirectOutput = options.output != null && options.output != string.Empty;
if (redirectOutput)
{
StreamWriter outStreamWriter = new StreamWriter(options.output);
outStreamWriter.AutoFlush = true;
outWriter = outStreamWriter;
}
TextWriter errorWriter = Console.Error;
bool redirectError = options.err != null && options.err != string.Empty;
if (redirectError)
{
StreamWriter errorStreamWriter = new StreamWriter(options.err);
errorStreamWriter.AutoFlush = true;
errorWriter = errorStreamWriter;
}
TextWriter testResultWriter = null;
if (options.IsResults)
{
testResultWriter = new StreamWriter(options.results, false, Encoding.UTF8);
((StreamWriter)testResultWriter).AutoFlush = true;
}
TestPackage package = MakeTestPackage(options);
Console.WriteLine("ProcessModel: {0} DomainUsage: {1}",
package.Settings.Contains("ProcessModel")
? package.Settings["ProcessModel"]
: "Default",
package.Settings.Contains("DomainUsage")
? package.Settings["DomainUsage"]
: "Default");
Console.WriteLine("Execution Runtime: {0}",
package.Settings.Contains("RuntimeFramework")
? package.Settings["RuntimeFramework"]
: "Default");
TestRunner testRunner = new DefaultTestRunnerFactory().MakeTestRunner(package);
testRunner.Load(package);
try
{
if (testRunner.Test == null)
{
testRunner.Unload();
Console.Error.WriteLine("Unable to locate fixture {0}", options.fixture);
return(FIXTURE_NOT_FOUND);
}
ExtendedEventCollector collector = new ExtendedEventCollector(options, outWriter, errorWriter, testResultWriter);
TestFilter testFilter = TestFilter.Empty;
if (options.run != null && options.run != string.Empty)
{
Console.WriteLine("Selected test(s): " + options.run);
testFilter = new SimpleNameFilter(options.run);
}
if (options.include != null && options.include != string.Empty)
{
Console.WriteLine("Included categories: " + options.include);
TestFilter includeFilter = new CategoryExpression(options.include).Filter;
if (testFilter.IsEmpty)
{
testFilter = includeFilter;
}
else
{
testFilter = new AndFilter(testFilter, includeFilter);
}
}
if (options.exclude != null && options.exclude != string.Empty)
{
Console.WriteLine("Excluded categories: " + options.exclude);
TestFilter excludeFilter = new NotFilter(new CategoryExpression(options.exclude).Filter);
if (testFilter.IsEmpty)
{
testFilter = excludeFilter;
}
else if (testFilter is AndFilter)
{
((AndFilter)testFilter).Add(excludeFilter);
}
else
{
testFilter = new AndFilter(testFilter, excludeFilter);
}
}
if (testFilter is NotFilter)
{
((NotFilter)testFilter).TopLevel = true;
}
TestResult result = null;
string savedDirectory = Environment.CurrentDirectory;
TextWriter savedOut = Console.Out;
TextWriter savedError = Console.Error;
try
{
result = testRunner.Run(collector, testFilter);
}
finally
{
outWriter.Flush();
errorWriter.Flush();
if (redirectOutput)
{
outWriter.Close();
}
if (redirectError)
{
errorWriter.Close();
}
if (options.IsResults)
{
testResultWriter.Close();
}
Environment.CurrentDirectory = savedDirectory;
Console.SetOut(savedOut);
Console.SetError(savedError);
}
Console.WriteLine();
int returnCode = UNEXPECTED_ERROR;
if (result != null)
{
string xmlOutput = CreateXmlOutput(result);
ResultSummarizer summary = new ResultSummarizer(result);
if (options.xmlConsole)
{
Console.WriteLine(xmlOutput);
}
else
{
WriteSummaryReport(summary);
if (summary.ErrorsAndFailures > 0)
{
WriteErrorsAndFailuresReport(result);
}
if (summary.TestsNotRun > 0)
{
WriteNotRunReport(result);
}
}
// Write xml output here
string xmlResultFile = options.xml == null || options.xml == string.Empty
? "TestResult.xml" : options.xml;
if (!String.IsNullOrEmpty(options.xml))
{
using (StreamWriter writer = new StreamWriter(xmlResultFile))
{
writer.Write(xmlOutput);
}
}
returnCode = summary.ErrorsAndFailures;
}
if (collector.HasExceptions)
{
collector.WriteExceptions();
returnCode = UNEXPECTED_ERROR;
}
return(returnCode);
}
finally
{
testRunner.Unload();
}
}
public static TestFilter FromXml(string xmlText)
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(xmlText);
XmlNode topNode = doc.FirstChild;
if (topNode.Name != "filter")
{
throw new Exception("Expected filter element at top level");
}
// Initially, an empty filter
TestFilter result = TestFilter.Empty;
bool isEmptyResult = true;
XmlNodeList testNodes = topNode.SelectNodes("tests/test");
XmlNodeList includeNodes = topNode.SelectNodes("include/category");
XmlNodeList excludeNodes = topNode.SelectNodes("exclude/category");
if (testNodes.Count > 0)
{
SimpleNameFilter nameFilter = new SimpleNameFilter();
foreach (XmlNode testNode in topNode.SelectNodes("tests/test"))
{
nameFilter.Add(testNode.InnerText);
}
result = nameFilter;
isEmptyResult = false;
}
if (includeNodes.Count > 0)
{
//CategoryFilter includeFilter = new CategoryFilter();
//foreach (XmlNode includeNode in includeNodes)
// includeFilter.AddCategory(includeNode.InnerText);
// Temporarily just look at the first element
XmlNode includeNode = includeNodes[0];
TestFilter includeFilter = new CategoryExpression(includeNode.InnerText).Filter;
if (isEmptyResult)
{
result = includeFilter;
}
else
{
result = new AndFilter(result, includeFilter);
}
isEmptyResult = false;
}
if (excludeNodes.Count > 0)
{
CategoryFilter categoryFilter = new CategoryFilter();
foreach (XmlNode excludeNode in excludeNodes)
{
categoryFilter.AddCategory(excludeNode.InnerText);
}
TestFilter excludeFilter = new NotFilter(categoryFilter);
if (isEmptyResult)
{
result = excludeFilter;
}
else
{
result = new AndFilter(result, excludeFilter);
}
isEmptyResult = false;
}
return(result);
}
public static TestFilter FromXml(string xmlText)
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(xmlText);
XmlNode topNode = doc.FirstChild;
if (topNode.Name != "filter")
throw new Exception("Expected filter element at top level");
// Initially, an empty filter
TestFilter result = TestFilter.Empty;
bool isEmptyResult = true;
XmlNodeList testNodes = topNode.SelectNodes("tests/test");
XmlNodeList includeNodes = topNode.SelectNodes("include/category");
XmlNodeList excludeNodes = topNode.SelectNodes("exclude/category");
if (testNodes.Count > 0)
{
SimpleNameFilter nameFilter = new SimpleNameFilter();
foreach (XmlNode testNode in topNode.SelectNodes("tests/test"))
nameFilter.Add(testNode.InnerText);
result = nameFilter;
isEmptyResult = false;
}
if (includeNodes.Count > 0)
{
//CategoryFilter includeFilter = new CategoryFilter();
//foreach (XmlNode includeNode in includeNodes)
// includeFilter.AddCategory(includeNode.InnerText);
// Temporarily just look at the first element
XmlNode includeNode = includeNodes[0];
TestFilter includeFilter = new CategoryExpression(includeNode.InnerText).Filter;
if (isEmptyResult)
result = includeFilter;
else
result = new AndFilter(result, includeFilter);
isEmptyResult = false;
}
if (excludeNodes.Count > 0)
{
CategoryFilter categoryFilter = new CategoryFilter();
foreach (XmlNode excludeNode in excludeNodes)
categoryFilter.AddCategory(excludeNode.InnerText);
TestFilter excludeFilter = new NotFilter(categoryFilter);
if (isEmptyResult)
result = excludeFilter;
else
result = new AndFilter(result, excludeFilter);
isEmptyResult = false;
}
return result;
}
protected override int DoRun(Console.ConsoleOptions options, bool redirectOutput, bool redirectError, TestPackage package, TextWriter outWriter, TextWriter errorWriter, TestFilter testFilter, out TestResult result, EventCollector collector)
{
result = null;
var testRunner1 = new DefaultTestRunnerFactory().MakeTestRunner(package);
try
{
testRunner1.Load(package);
if (testRunner1.Test == null)
{
testRunner1.Unload();
System.Console.Error.WriteLine("Unable to locate fixture {0}", options.fixture);
return FIXTURE_NOT_FOUND;
}
}
finally
{
var disp = testRunner1 as IDisposable;
if (disp != null)
disp.Dispose();
}
result = new TestResult(new TestName { Name = "Global" });
var timer = new Stopwatch();
timer.Start();
var testRunnerId = 0;
{
var syncTestRunner = new DefaultTestRunnerFactory().MakeTestRunner(package);
var syncFilter = new AndFilter(testFilter, new SynchronousFilter());
var logger = new ConsoleLoggingEventListener(collector);
result.AddResult(RunPartition(redirectOutput, redirectError, package, outWriter, errorWriter, syncFilter, syncTestRunner, logger));
testRunnerId = syncTestRunner.ID;
}
var dep = 0;
var consoleOptions = options as ConsoleOptions;
if (options != null)
dep = consoleOptions.degreeofparallelism;
if (dep == 0)
dep = 4;
System.Console.WriteLine("Degree of Parallelism: {0}", dep);
var state = new AsynchronousFilterState(dep);
var asyncTestRunner = new ParallelTestRunner(testRunnerId + 1, dep, state);
result.AddResult(RunPartition(redirectOutput, redirectError, package, outWriter, errorWriter, testFilter, asyncTestRunner, collector));
if (consoleOptions != null && consoleOptions.retestfailures)
{
var failedTests = (from test in Flatten(result)
where test.Result.IsFailure
select test).ToList();
var failedTestFilter = new SimpleNameFilter(failedTests.Select(t => t.Result.FullName));
var retestTestRunner = new DefaultTestRunnerFactory().MakeTestRunner(package);
var retestFilter = new AndFilter(testFilter, failedTestFilter);
var logger = new ConsoleLoggingEventListener(collector);
var retestResults = RunPartition(redirectOutput, redirectError, package, outWriter, errorWriter, retestFilter, retestTestRunner, logger);
var newTests = Flatten(retestResults).ToDictionary(test => test.Result.FullName);
foreach (var failedTest in failedTests)
{
var newTest = newTests[failedTest.Result.FullName];
if (newTest.Result.IsSuccess)
{
failedTest.Parent.Results.Remove(failedTest.Result);
failedTest.Parent.Results.Add(newTest.Result);
}
}
}
result = MergeResults(result.Test, (TestResult)result.Results[0], (TestResult)result.Results[1]);
timer.Stop();
result.Time = timer.ElapsedTicks / (double)TimeSpan.TicksPerSecond;
return 0;
}
public int Execute(ConsoleOptions options)
{
this.workDir = options.work;
if (workDir == null || workDir == string.Empty)
{
workDir = Environment.CurrentDirectory;
}
else
{
workDir = Path.GetFullPath(workDir);
if (!Directory.Exists(workDir))
{
Directory.CreateDirectory(workDir);
}
}
TextWriter outWriter = Console.Out;
bool redirectOutput = options.output != null && options.output != string.Empty;
if (redirectOutput)
{
StreamWriter outStreamWriter = new StreamWriter(Path.Combine(workDir, options.output));
outStreamWriter.AutoFlush = true;
outWriter = outStreamWriter;
}
TextWriter errorWriter = Console.Error;
bool redirectError = options.err != null && options.err != string.Empty;
if (redirectError)
{
StreamWriter errorStreamWriter = new StreamWriter(Path.Combine(workDir, options.err));
errorStreamWriter.AutoFlush = true;
errorWriter = errorStreamWriter;
}
TestPackage package = MakeTestPackage(options);
ProcessModel processModel = package.Settings.Contains("ProcessModel")
? (ProcessModel)package.Settings["ProcessModel"]
: ProcessModel.Default;
DomainUsage domainUsage = package.Settings.Contains("DomainUsage")
? (DomainUsage)package.Settings["DomainUsage"]
: DomainUsage.Default;
RuntimeFramework framework = package.Settings.Contains("RuntimeFramework")
? (RuntimeFramework)package.Settings["RuntimeFramework"]
: RuntimeFramework.CurrentFramework;
#if CLR_2_0 || CLR_4_0
Console.WriteLine("ProcessModel: {0} DomainUsage: {1}", processModel, domainUsage);
Console.WriteLine("Execution Runtime: {0}", framework);
#else
Console.WriteLine("DomainUsage: {0}", domainUsage);
if (processModel != ProcessModel.Default && processModel != ProcessModel.Single)
{
Console.WriteLine("Warning: Ignoring project setting 'processModel={0}'", processModel);
}
if (!RuntimeFramework.CurrentFramework.Supports(framework))
{
Console.WriteLine("Warning: Ignoring project setting 'runtimeFramework={0}'", framework);
}
#endif
using (TestRunner testRunner = new DefaultTestRunnerFactory().MakeTestRunner(package))
{
testRunner.Load(package);
if (testRunner.Test == null)
{
testRunner.Unload();
Console.Error.WriteLine("Unable to locate fixture {0}", options.fixture);
return(FIXTURE_NOT_FOUND);
}
EventCollector collector = new EventCollector(options, outWriter, errorWriter);
TestFilter testFilter = TestFilter.Empty;
SimpleNameFilter nameFilter = new SimpleNameFilter();
if (options.run != null && options.run != string.Empty)
{
Console.WriteLine("Selected test(s): " + options.run);
foreach (string name in TestNameParser.Parse(options.run))
{
nameFilter.Add(name);
}
testFilter = nameFilter;
}
if (options.runlist != null && options.runlist != string.Empty)
{
Console.WriteLine("Run list: " + options.runlist);
using (StreamReader rdr = new StreamReader(options.runlist))
{
// NOTE: We can't use rdr.EndOfStream because it's
// not present in .NET 1.x.
string line = rdr.ReadLine();
while (line != null)
{
if (line[0] != '#')
{
nameFilter.Add(line);
}
line = rdr.ReadLine();
}
}
testFilter = nameFilter;
}
if (options.include != null && options.include != string.Empty)
{
TestFilter includeFilter = new CategoryExpression(options.include).Filter;
Console.WriteLine("Included categories: " + includeFilter.ToString());
if (testFilter.IsEmpty)
{
testFilter = includeFilter;
}
else
{
testFilter = new AndFilter(testFilter, includeFilter);
}
}
if (options.exclude != null && options.exclude != string.Empty)
{
TestFilter excludeFilter = new NotFilter(new CategoryExpression(options.exclude).Filter);
Console.WriteLine("Excluded categories: " + excludeFilter.ToString());
if (testFilter.IsEmpty)
{
testFilter = excludeFilter;
}
else if (testFilter is AndFilter)
{
((AndFilter)testFilter).Add(excludeFilter);
}
else
{
testFilter = new AndFilter(testFilter, excludeFilter);
}
}
if (testFilter is NotFilter)
{
((NotFilter)testFilter).TopLevel = true;
}
TestResult result = null;
string savedDirectory = Environment.CurrentDirectory;
TextWriter savedOut = Console.Out;
TextWriter savedError = Console.Error;
try
{
result = testRunner.Run(collector, testFilter, false, LoggingThreshold.Off);
}
finally
{
outWriter.Flush();
errorWriter.Flush();
if (redirectOutput)
{
outWriter.Close();
}
if (redirectError)
{
errorWriter.Close();
}
Environment.CurrentDirectory = savedDirectory;
Console.SetOut(savedOut);
Console.SetError(savedError);
}
Console.WriteLine();
int returnCode = UNEXPECTED_ERROR;
if (result != null)
{
string xmlOutput = CreateXmlOutput(result);
ResultSummarizer summary = new ResultSummarizer(result);
if (options.xmlConsole)
{
Console.WriteLine(xmlOutput);
}
else
{
WriteSummaryReport(summary);
if (summary.ErrorsAndFailures > 0 || result.IsError || result.IsFailure)
{
if (options.stoponerror)
{
Console.WriteLine("Test run was stopped after first error, as requested.");
Console.WriteLine();
}
WriteErrorsAndFailuresReport(result);
}
if (summary.TestsNotRun > 0)
{
WriteNotRunReport(result);
}
if (!options.noresult)
{
// Write xml output here
string xmlResultFile = options.result == null || options.result == string.Empty
? "TestResult.xml" : options.result;
using (StreamWriter writer = new StreamWriter(Path.Combine(workDir, xmlResultFile)))
{
writer.Write(xmlOutput);
}
}
}
returnCode = summary.ErrorsAndFailures;
}
if (collector.HasExceptions)
{
collector.WriteExceptions();
returnCode = UNEXPECTED_ERROR;
}
return(returnCode);
}
}
public void RunOnly(string testName)
{
var nameFilter = new SimpleNameFilter(testName);
filter = And(filter, nameFilter);
}
