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 override void Run(TestCaseResult result) { base.Run( result ); if ( result.IsSuccess && !ExceptionExpected ) { int elapsedTime = (int)(result.Time * 1000); if ( elapsedTime > maxTime && !expectFailure) result.Failure( string.Format( "Elapsed time of {0}ms exceeds maximum of {1}ms", elapsedTime, maxTime ), null ); else if ( elapsedTime <= maxTime && expectFailure ) result.Failure( "Expected a timeout failure, but none occured", null ); } }
public override void Run(TestCaseResult result) { base.Run(result); if (result.IsSuccess && !ExceptionExpected) { int elapsedTime = (int)(result.Time * 1000); if (elapsedTime > maxTime && !expectFailure) { result.Failure(string.Format("Elapsed time of {0}ms exceeds maximum of {1}ms", elapsedTime, maxTime), null); } else if (elapsedTime <= maxTime && expectFailure) { result.Failure("Expected a timeout failure, but none occured", null); } } }
public void TestCaseFailure() { caseResult.Failure("message", "stack trace"); Assert.IsTrue(caseResult.IsFailure); Assert.IsFalse(caseResult.IsSuccess); Assert.AreEqual("message", caseResult.Message); Assert.AreEqual("stack trace", caseResult.StackTrace); }
public void SetResult_Failure() { TestSuiteTreeNode node = new TestSuiteTreeNode(testCaseInfo); TestCaseResult result = new TestCaseResult(testCaseInfo); result.Failure("message", "stacktrace"); node.Result = result; Assert.AreEqual(TestSuiteTreeNode.FailureIndex, node.ImageIndex); Assert.AreEqual(TestSuiteTreeNode.FailureIndex, node.SelectedImageIndex); Assert.AreEqual("Failure", 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 Run(TestCaseResult testResult) { if (ShouldRun) { bool needParentTearDown = false; try { if (Parent != null) { if (Parent.SetUpNeeded) { Parent.DoOneTimeSetUp(testResult); needParentTearDown = Parent.SetUpComplete; } if (Parent.SetUpFailed) { testResult.Failure("TestFixtureSetUp Failed", testResult.StackTrace); } } if (!testResult.IsFailure) { doRun(testResult); } } catch (Exception ex) { if (ex is NunitException) { ex = ex.InnerException; } RecordException(ex, testResult); } finally { if (needParentTearDown) { Parent.DoOneTimeTearDown(testResult); } } } else { testResult.NotRun(IgnoreReason); } }
public void ClearResult() { TestCaseResult result = new TestCaseResult(testCaseInfo); result.Failure("message", "stacktrace"); TestSuiteTreeNode node = new TestSuiteTreeNode(result); Assert.AreEqual(TestSuiteTreeNode.FailureIndex, node.ImageIndex); Assert.AreEqual(TestSuiteTreeNode.FailureIndex, node.SelectedImageIndex); node.ClearResult(); Assert.AreEqual(null, node.Result); Assert.AreEqual(TestSuiteTreeNode.InitIndex, node.ImageIndex); Assert.AreEqual(TestSuiteTreeNode.InitIndex, node.SelectedImageIndex); }
public override TestResult Run(EventListener listener, ITestFilter filter) { TestSuiteResult suite_result = new TestSuiteResult(new TestInfo(this), TestName.FullName); DebuggerTestHost host = DebuggerTestHost.Create(); if (host == null) { TestCaseResult error = new TestCaseResult(new TestInfo(this)); string msg = String.Format("Failed to create DebuggerTestHost in {0}", FixtureType.Name); error.Failure(msg, null, FailureSite.Parent); suite_result.AddResult(error); return(suite_result); } int timeout; if (Attribute.Timeout != 0) { timeout = Attribute.Timeout; } else { timeout = DebuggerTestAddIn.DefaultTimeout; } int repeat = 1; if (Attribute.Repeat != 0) { repeat = Attribute.Repeat; } try { for (int i = 0; i < repeat; i++) { if (!host.Run(new TestInfo(this), suite_result, Type.AssemblyQualifiedName, listener, filter, timeout)) { break; } } return(suite_result); } finally { host.Dispose(); } }
protected void RecordTearDownException(Exception exception, TestCaseResult testResult) { StringBuilder msg = new StringBuilder(); StringBuilder st = new StringBuilder(); msg.Append(testResult.Message); msg.Append(Environment.NewLine); msg.Append("TearDown : "); st.Append(testResult.StackTrace); st.Append(Environment.NewLine); st.Append("--TearDown"); st.Append(Environment.NewLine); msg.Append(BuildMessage(exception)); st.Append(BuildStackTrace(exception)); testResult.Failure(msg.ToString(), st.ToString()); }
public void TestSuiteFailure() { TestSuiteResult result = MockSuiteResult(); AssertionException failure = new AssertionException("an assertion failed error"); testCase.Failure(failure.Message, failure.StackTrace); Assert.IsTrue(result.IsFailure); Assert.IsFalse(result.IsSuccess); IList results = result.Results; TestSuiteResult suiteA = (TestSuiteResult)results[0]; Assert.IsTrue(suiteA.IsFailure); TestSuiteResult suiteB = (TestSuiteResult)results[1]; Assert.IsTrue(suiteB.IsSuccess); }
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 bool Run(TestInfo test, TestSuiteResult suite_result, string test_name, EventListener listener, ITestFilter filter, int timeout) { listener = new ProxyListener(listener); TestRunnerDelegate runner = new TestRunnerDelegate(delegate { return(server.Run(test_name, listener, filter)); }); IAsyncResult ar = runner.BeginInvoke(test_name, null, filter, null, null); if (!ar.AsyncWaitHandle.WaitOne(timeout) || !ar.IsCompleted) { TestCaseResult error = new TestCaseResult(test); string msg = String.Format("Timeout after {0} ms", timeout); error.Failure(msg, null, FailureSite.Parent); suite_result.AddResult(error); return(false); } try { TestResult result = runner.EndInvoke(ar); if (result != null) { suite_result.AddResult(result); return(true); } TestCaseResult error = new TestCaseResult(test); error.Failure("Unknown error", null, FailureSite.Parent); suite_result.AddResult(error); return(false); } catch (Exception ex) { TestCaseResult error = new TestCaseResult(test); string msg = String.Format("Unknown exception: {0}", ex); error.Failure(msg, null, FailureSite.Parent); suite_result.AddResult(error); return(false); } }
private void MarkTestFailed( Test test, TestSuiteResult suiteResult, EventListener listener, ITestFilter filter) { if (test is TestSuite) { listener.SuiteStarted(test.TestName); TestSuiteResult result = new TestSuiteResult(new TestInfo(test), test.TestName.FullName); string msg = string.Format("Parent SetUp failed in {0}", this.FixtureType.Name); result.Failure(msg, null, FailureSite.Parent); MarkTestsFailed(test.Tests, suiteResult, listener, filter); suiteResult.AddResult(result); listener.SuiteFinished(result); } else { listener.TestStarted(test.TestName); TestCaseResult result = new TestCaseResult(new TestInfo(test)); string msg = string.Format("TestFixtureSetUp failed in {0}", this.FixtureType.Name); result.Failure(msg, null, FailureSite.Parent); suiteResult.AddResult(result); listener.TestFinished(result); } }
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); } }
//private TestCaseResult testCase; private TestSuiteResult MockSuiteResult(bool failure) { TestCaseResult testCaseResult = new TestCaseResult("a test case"); if (failure) { testCaseResult.Failure("case failed", null); } TestSuiteResult level1SuiteA = new TestSuiteResult("level 1 A"); level1SuiteA.AddResult(testCaseResult); TestSuiteResult level1SuiteB = new TestSuiteResult("level 1 B"); level1SuiteB.AddResult(new TestCaseResult("a successful test")); TestSuiteResult result = new TestSuiteResult("base"); result.AddResult(level1SuiteA); result.AddResult(level1SuiteB); return(result); }
public void TestCaseFailure() { caseResult.Failure("an assertion failed error", null); Assert.IsTrue(caseResult.IsFailure); Assert.IsFalse(caseResult.IsSuccess); }