public void WhenResultIsCleared_NestedResultsAreAlsoCleared()
{
TestResult testCaseResult = new TestResult(testCase);
testCaseResult.Success();
TestResult testSuiteResult = new TestResult(testFixture);
testSuiteResult.AddResult(testCaseResult);
testSuiteResult.Success();
TestSuiteTreeNode node1 = new TestSuiteTreeNode(testSuiteResult);
TestSuiteTreeNode node2 = new TestSuiteTreeNode(testCaseResult);
node1.Nodes.Add(node2);
Assert.AreEqual(TestSuiteTreeNode.SuccessIndex, node1.ImageIndex);
Assert.AreEqual(TestSuiteTreeNode.SuccessIndex, node1.SelectedImageIndex);
Assert.AreEqual(TestSuiteTreeNode.SuccessIndex, node2.ImageIndex);
Assert.AreEqual(TestSuiteTreeNode.SuccessIndex, node2.SelectedImageIndex);
node1.ClearResults();
Assert.AreEqual(TestSuiteTreeNode.InitIndex, node1.ImageIndex);
Assert.AreEqual(TestSuiteTreeNode.InitIndex, node1.SelectedImageIndex);
Assert.AreEqual(TestSuiteTreeNode.InitIndex, node2.ImageIndex);
Assert.AreEqual(TestSuiteTreeNode.InitIndex, node2.SelectedImageIndex);
}
public void ClearNestedResults()
{
TestResult testCaseResult = new TestResult(testCaseInfo);
testCaseResult.Success();
TestResult testSuiteResult = new TestResult(fixtureInfo);
testSuiteResult.AddResult(testCaseResult);
testSuiteResult.Success();
TestSuiteTreeNode node1 = new TestSuiteTreeNode(testSuiteResult);
TestSuiteTreeNode node2 = new TestSuiteTreeNode(testCaseResult);
node1.Nodes.Add(node2);
Assert.AreEqual(TestSuiteTreeNode.SuccessIndex, node1.ImageIndex);
Assert.AreEqual(TestSuiteTreeNode.SuccessIndex, node1.SelectedImageIndex);
Assert.AreEqual(TestSuiteTreeNode.SuccessIndex, node2.ImageIndex);
Assert.AreEqual(TestSuiteTreeNode.SuccessIndex, node2.SelectedImageIndex);
node1.ClearResults();
Assert.AreEqual(TestSuiteTreeNode.InitIndex, node1.ImageIndex);
Assert.AreEqual(TestSuiteTreeNode.InitIndex, node1.SelectedImageIndex);
Assert.AreEqual(TestSuiteTreeNode.InitIndex, node2.ImageIndex);
Assert.AreEqual(TestSuiteTreeNode.InitIndex, node2.SelectedImageIndex);
}
// All forms of Run and BeginRun eventually come here
public virtual TestResult Run(EventListener listener, ITestFilter filter)
{
Log.Info("Run - EventListener={0}", listener.GetType().Name);
// Save active listener for derived classes
this.listener = listener;
ITest[] tests = new ITest[runners.Count];
for (int index = 0; index < runners.Count; index++)
{
tests[index] = ((TestRunner)runners[index]).Test;
}
string name = this.testName.Name;
int count = this.CountTestCases(filter);
Log.Info("Signalling RunStarted({0},{1})", name, count);
this.listener.RunStarted(name, count);
long startTime = DateTime.Now.Ticks;
TestResult result = new TestResult(new TestInfo(testName, tests));
if (this.runInParallel)
{
foreach (TestRunner runner in runners)
{
if (filter.Pass(runner.Test))
{
runner.BeginRun(this, filter);
}
}
result = this.EndRun();
}
else
{
foreach (TestRunner runner in runners)
{
if (filter.Pass(runner.Test))
{
result.AddResult(runner.Run(this, filter));
}
}
}
long stopTime = DateTime.Now.Ticks;
double time = ((double)(stopTime - startTime)) / (double)TimeSpan.TicksPerSecond;
result.Time = time;
this.listener.RunFinished(result);
this.testResult = result;
return(result);
}
internal void SaveResults(string fileName)
{
TestResult all = new TestResult(new TestName());
foreach (TestResult r in mResultList)
{
all.AddResult(r);
}
new XmlResultWriter(fileName).SaveTestResult(all);
}
private TestResult CreateResults(string recipe)
{
TestResult result = new TestResult(new TestSuite("From Recipe"));
foreach (char c in recipe)
{
TestResult r = new TestResult(new TestCase("test"));
switch (c)
{
case 'S':
r.Success();
break;
case 'F':
r.Failure("failed!");
break;
case 'E':
r.Error(new Exception("error!"));
break;
default:
break;
}
result.AddResult(r);
}
if (recipe.IndexOfAny(new char[] { 'E', 'F' }) >= 0)
{
result.Failure("Errors");
}
else
{
result.Success();
}
return(result);
}
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);
}
/// <summary>
/// Runs all of the tests defined in the specified assembly, specifically not running
/// any of the tests in the calling type.
/// </summary>
/// <param name="assemblyToTest">
/// The assembly to be tested.
/// </param>
/// <param name="callingType">
/// No tests will be run that are defined in this type.
/// </param>
/// <returns>
/// The result of running the suite of tests.
/// </returns>
private TestResult RunTestsInParallelImpl(Assembly assemblyToTest, Type callingType)
{
// NUnit requires this initialization step before any tests can be run
CoreExtensions.Host.InitializeService();
this.Listener = new ParallelListener();
this.Filter = new IgnoreFilter(this.Listener);
List <Test> concurrentTestFixtures;
try
{
concurrentTestFixtures = assemblyToTest.GetTypes()
.Where(type => callingType != type && TestFixtureBuilder.CanBuildFrom(type))
.Select(TestFixtureBuilder.BuildFrom)
.ToList();
}
catch (ReflectionTypeLoadException ex)
{
Console.WriteLine("ReflectionTypeLoadException caught...");
foreach (Exception loaderException in ex.LoaderExceptions)
{
Console.WriteLine("Loader Exception --------------------");
Console.WriteLine("Message:{0}", loaderException.Message);
if (loaderException is FileNotFoundException)
{
Console.WriteLine((loaderException as FileNotFoundException).FusionLog);
}
Console.WriteLine("StackTrace: {0}", loaderException.StackTrace);
}
throw;
}
var stopwatch = new Stopwatch();
stopwatch.Start();
var currentDirectory = Path.GetDirectoryName(assemblyToTest.Location);
Parallel.ForEach(concurrentTestFixtures, testFixture =>
{
Environment.CurrentDirectory = currentDirectory;
TestContext.Save();
testFixture.Run(this.Listener, this.Filter);
});
stopwatch.Stop();
// Find out what the failures were
var testResults = this.AllResults(this.Listener.Results)
.Where(x => x.Results == null)
.ToList();
var failuresAndErrors = testResults
.Where(result => (result.IsFailure || result.IsError))
.ToList();
// Report the errors if there are any
Console.WriteLine();
foreach (TestResult failure in failuresAndErrors)
{
Console.WriteLine("------------------------------------------------");
Console.WriteLine(failure.Test.TestName + " failed");
Console.WriteLine(failure.Message);
Console.WriteLine(failure.StackTrace);
}
Console.WriteLine("=================================================");
var totalErrors = testResults.Count(x => x.IsError);
var totalFailures = testResults.Count(x => x.IsFailure);
var totalInconclusive = testResults.Count(x => x.ResultState == ResultState.Inconclusive);
var totalIgnored = testResults.Count(x => x.ResultState == ResultState.Ignored);
var totalSkipped = testResults.Count(x => x.ResultState == ResultState.Skipped);
var totalNotRunnable = testResults.Count(x => x.ResultState == ResultState.NotRunnable);
var totalNotRun = totalInconclusive + totalIgnored + totalSkipped + totalNotRunnable;
var totalRun = testResults.Count - totalNotRun;
Console.WriteLine(
String.Format("Tests run: {0}, Errors: {1}, Failures: {2}, Inconclusive: {3}, Time: {4} seconds",
totalRun,
totalErrors,
totalFailures,
totalInconclusive,
stopwatch.Elapsed.TotalSeconds));
Console.WriteLine(String.Format(" Not run: {0}, Invalid: {1}, Ignored: {2}, Skipped: {3}",
totalNotRun,
failuresAndErrors.Count,
totalIgnored,
totalSkipped));
Console.WriteLine("=================================================");
// Build up the results for return
var finalResult = new TestResult(new TestName());
foreach (var result in this.Listener.Results)
{
finalResult.AddResult(result);
}
return(finalResult);
}
public void ReportExpectation(IExpectation expectation)
{
var result = CreateTestResultFromExpectation(expectation);
testResult.AddResult(result);
}
