void ReportResult(string failureMessage, string stackTrace, TestCaseResult res)
{
if (_inverseResult)
{
if (failureMessage != null)
{
res.Success();
}
else
{
res.Failure("The following test was FIXED: " + _testid, null);
}
}
else
{
if (failureMessage != null)
{
res.Failure(failureMessage, stackTrace);
}
else
{
res.Success();
}
}
}
public void ClearResults()
{
TestCaseResult testCaseResult = new TestCaseResult(testCaseInfo);
testCaseResult.Success();
TestSuiteResult testSuiteResult = new TestSuiteResult(fixtureInfo, "MockTestFixture");
testSuiteResult.AddResult(testCaseResult);
testSuiteResult.RunState = RunState.Executed;
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 override void RunTestMethod(TestCaseResult testResult)
#endif
{
object[] arguments = _arguments != null ? _arguments : new object[] { null };
Reflect.InvokeMethod(this.Method, this.Fixture, arguments);
testResult.Success(); // If no exception occured
}
public void SetResult_Success()
{
TestSuiteTreeNode node = new TestSuiteTreeNode(testCaseInfo);
TestCaseResult result = new TestCaseResult(testCaseInfo);
result.Success();
node.Result = result;
Assert.AreEqual(TestSuiteTreeNode.SuccessIndex, node.ImageIndex);
Assert.AreEqual(TestSuiteTreeNode.SuccessIndex, node.SelectedImageIndex);
Assert.AreEqual("Success", node.StatusText);
}
public override void Run(TestCaseResult res)
{
try
{
Harness.RunSingleTest(_baseUrl, _testInfo);
}
catch (Exception e)
{
res.Failure(e.Message, null);
return;
}
res.Success();
}
public override void RunTestMethod(TestCaseResult testResult)
{
var module = GetModule();
if (module == null)
{
return;
}
Reflect.InvokeMethod(Method, Fixture, new object [] { module });
testResult.Success();
}
public override void Run(TestCaseResult res)
{
string type = _test.GetAttribute("TYPE");
if (type == "error")
{
res.Success();
}
Uri baseUri = new Uri(_test.BaseURI);
Uri testUri = new Uri(baseUri, _test.GetAttribute("URI"));
bool nonValidatingPassed = TestNonValidating(testUri.ToString());
bool validatingPassed = TestValidating(testUri.ToString());
bool isok = isOK(type, nonValidatingPassed, validatingPassed);
string message = "";
if (_inverseResult)
{
isok = !isok;
message = "The following test was FIXED:\n";
}
if (isok)
{
res.Success();
}
else
{
message += "type:" + type;
message += " non-validating passed:" + nonValidatingPassed.ToString();
message += " validating passed:" + validatingPassed.ToString();
message += " description:" + _test.InnerText;
res.Failure(message, _errorString);
}
}
public void SetResult()
{
TestSuiteTreeNode node = new TestSuiteTreeNode(testCaseInfo);
TestCaseResult result = new TestCaseResult(testCase);
node.SetResult(result);
Assert.AreEqual("NUnit.Tests.Assemblies.MockTestFixture.MockTest1", node.Result.Name);
Assert.AreEqual(TestSuiteTreeNode.NotRunIndex, node.ImageIndex);
Assert.AreEqual(TestSuiteTreeNode.NotRunIndex, node.SelectedImageIndex);
result.Success();
node.SetResult(result);
Assert.AreEqual(TestSuiteTreeNode.SuccessIndex, node.ImageIndex);
Assert.AreEqual(TestSuiteTreeNode.SuccessIndex, node.SelectedImageIndex);
result.Failure("message", "stacktrace");
node.SetResult(result);
Assert.AreEqual(TestSuiteTreeNode.FailureIndex, node.ImageIndex);
Assert.AreEqual(TestSuiteTreeNode.FailureIndex, node.SelectedImageIndex);
}
private TestSuiteResult MockSuiteResult(string suiteName, bool failure)
{
TestSuiteResult result = new TestSuiteResult(null, suiteName);
result.Time = time;
result.Executed = true;
TestSuiteResult level1SuiteA = new TestSuiteResult(null, "level 1 A");
result.AddResult(level1SuiteA);
level1SuiteA.Executed = true;
TestSuiteResult level1SuiteB = new TestSuiteResult(null, "level 1 B");
result.AddResult(level1SuiteB);
level1SuiteB.Executed = true;
testCase = new TestCaseResult("a test case");
if (failure)
{
testCase.Failure("argument exception", null);
}
else
{
testCase.Success();
}
level1SuiteA.AddResult(testCase);
testCase = new TestCaseResult("a successful test");
testCase.Success();
level1SuiteB.AddResult(testCase);
testCase = new TestCaseResult("a not run test");
testCase.NotRun("test not run");
level1SuiteB.AddResult(testCase);
return(result);
}
public override void Run(TestCaseResult testResult)
{
DateTime start = DateTime.Now;
try
{
try
{
_fixture.Setup();
}
catch (Exception ex)
{
testResult.Error(ex, FailureSite.SetUp);
return;
}
_testCase.Execute();
testResult.Success();
}
catch (Exception ex)
{
testResult.Error(ex, FailureSite.Test);
}
finally
{
try
{
_fixture.Teardown();
}
catch (Exception ex)
{
testResult.Error(ex, FailureSite.TearDown);
}
DateTime stop = DateTime.Now;
TimeSpan span = stop.Subtract(start);
testResult.Time = span.Ticks / (double)TimeSpan.TicksPerSecond;
}
}
private void doTestCase(TestCaseResult testResult)
{
try
{
RunTestMethod(testResult);
testResult.Success();
}
catch (Exception ex)
{
if (ex is NunitException)
{
ex = ex.InnerException;
}
if (testFramework.IsIgnoreException(ex))
{
testResult.NotRun(ex.Message, BuildStackTrace(ex));
}
else
{
RecordException(ex, testResult);
}
}
}
public void TestCaseSuccess()
{
caseResult.Success();
Assert.IsTrue(caseResult.IsSuccess, "result should be success");
}
public virtual void RunTestMethod(TestCaseResult testResult)
{
_testCase.Execute();
testResult.Success();
}