public override TestResult Run(EventListener listener, ITestFilter filter) { listener.TestStarted(base.TestName); long ticks = DateTime.Now.Ticks; TestResult testResult = new TestResult(this); Exception existingError = null; _globalSetup.PrepareForTestPosition(Position, out existingError); if (existingError != null) { TestResultUtil.Error(testResult, existingError, null, FailureSite.SetUp); } else { List<string> traceMessages = null; try { RunTestMethod(testResult, out traceMessages); } catch (Exception e) { var globalTraceMessages = _globalSetup.GetTraceMessages(); TestResultUtil.Error(testResult, e, globalTraceMessages.Concat(traceMessages)); } } double num3 = ((double)(DateTime.Now.Ticks - ticks)) / 10000000.0; testResult.Time = num3; listener.TestFinished(testResult); return testResult; }
private object RunTaskAsyncMethod(TestResult testResult) { try { object task = base.RunTestMethod(testResult); Reflect.InvokeMethod(method.ReturnType.GetMethod(TaskWaitMethod, new Type[0]), task); PropertyInfo resultProperty = Reflect.GetNamedProperty(method.ReturnType, TaskResultProperty, TaskResultPropertyBindingFlags); return resultProperty != null ? resultProperty.GetValue(task, null) : task; } catch (NUnitException e) { if (e.InnerException != null && e.InnerException.GetType().FullName.Equals(SystemAggregateException)) { IList<Exception> inner = (IList<Exception>)e.InnerException.GetType() .GetProperty(InnerExceptionsProperty).GetValue(e.InnerException, null); throw new NUnitException("Rethrown", inner[0]); } throw; } }
/// <summary> /// Merges the specified other. /// </summary> /// <param name="source"> </param> /// <param name="target"> </param> public void Merge(TestResult source, TestResult target) { var mergedType = GetType(target); var otherType = GetType(source); if (mergedType == TestType.Project && otherType == TestType.Project) { if (string.IsNullOrEmpty(target.FullName) && !string.IsNullOrEmpty(source.FullName)) { target.Test.TestName.FullName = source.FullName; target.Test.TestName.Name = source.Name; } } if (mergedType != otherType) throw new NotSupportedException("Only merging of results with same test type are supported"); if (!target.IsSuccess && source.IsSuccess) { target.Success(source.Message); target.SetAgentName(source.GetAgentName()); } MergeChildren(source, target); }
/// <summary> /// Construct a TestNode given a TestResult /// </summary> public TestSuiteTreeNode( TestResult result ) : base(result.Test.TestName.Name) { this.test = result.Test; this.result = result; UpdateImageIndex(); }
public void SuiteFinished(TestResult suiteResult) { if (--testRecord.level == 0) { testRecord.CompleteTestSuite(suiteResult); } }
public void TestFinished(TestResult result) { totalAssertsExecutedInThisRun = totalAssertsExecutedInThisRun + result.AssertCount; if (!result.IsSuccess) totalAssertsExecutedInThisRun++; }
public void RunFinished(TestResult result) { if (m_EventListener != null) { m_EventListener.RunFinished(result); } }
public override TestResult Run(EventListener listener, ITestFilter filter) { using (new global::NUnit.Core.TestContext()) { var testResult = new TestResult(this); Log.Debug("Test Starting: " + TestName.FullName); listener.TestStarted(TestName); var stopwatch = new Stopwatch(); stopwatch.Start(); switch (RunState) { case RunState.Runnable: case RunState.Explicit: DoTest(_test, testResult); break; case RunState.NotRunnable: testResult.Invalid(IgnoreReason); break; case RunState.Ignored: testResult.Ignore(IgnoreReason); break; default: testResult.Skip(IgnoreReason); break; } stopwatch.Stop(); testResult.Time = stopwatch.Elapsed.Seconds; listener.TestFinished(testResult); return testResult; } }
public void TestFinished(TestResult result) { // Put results into data table DataRow dr = m_results.NewRow(); dr["test"] = result.Test.TestName; dr["message"] = result.Message; if (result.IsFailure) dr["message"] += result.StackTrace; dr["class"] = "notRun"; dr["time"] = result.Time; if (result.IsSuccess && result.Executed) { dr["result"] = "Pass"; dr["class"] = "pass"; } if (result.IsFailure && result.Executed) { dr["result"] = "Fail"; dr["class"] = "fail"; m_failedCount++; } if (result.Executed) m_executedCount++; m_results.Rows.Add(dr); }
public void TestFinished(TestResult result) { // Put results into data table var dr = _results.NewRow(); dr["test"] = result.Test.TestName; dr["class"] = "notRun"; dr["time"] = result.Time; var message = result.Message; if (result.IsFailure) message += "\r\n" + result.StackTrace; if (!string.IsNullOrEmpty(message)) message = message.Replace("\r\n", "<br/>"); dr["message"] = message; if (result.IsSuccess && result.Executed) { dr["result"] = "Pass"; dr["class"] = "pass"; } if (result.IsFailure && result.Executed) { dr["result"] = "Fail"; dr["class"] = "fail"; _failedCount++; } if (result.Executed) _executedCount++; _results.Rows.Add(dr); }
private void InitializeXmlFile(TestResult result) { ResultSummarizer summaryResults = new ResultSummarizer(result); xmlWriter.Formatting = Formatting.Indented; xmlWriter.WriteStartDocument(false); xmlWriter.WriteComment("This file represents the results of running a test suite"); xmlWriter.WriteStartElement("test-results"); xmlWriter.WriteAttributeString("name", summaryResults.Name); xmlWriter.WriteAttributeString("total", summaryResults.TestsRun.ToString()); xmlWriter.WriteAttributeString("errors", summaryResults.Errors.ToString()); xmlWriter.WriteAttributeString("failures", summaryResults.Failures.ToString()); xmlWriter.WriteAttributeString("not-run", summaryResults.TestsNotRun.ToString()); xmlWriter.WriteAttributeString("inconclusive", summaryResults.Inconclusive.ToString()); xmlWriter.WriteAttributeString("ignored", summaryResults.Ignored.ToString()); xmlWriter.WriteAttributeString("skipped", summaryResults.Skipped.ToString()); xmlWriter.WriteAttributeString("invalid", summaryResults.NotRunnable.ToString()); DateTime now = DateTime.Now; xmlWriter.WriteAttributeString("date", XmlConvert.ToString( now, "yyyy-MM-dd" ) ); xmlWriter.WriteAttributeString("time", XmlConvert.ToString( now, "HH:mm:ss" )); WriteEnvironment(); WriteCultureInfo(); }
/// <summary> /// Called when a test case has finished /// </summary> /// <param name="result">The result of the test</param> public void TestFinished(TestResult result) { if (this.eventListener != null) { this.eventListener.TestFinished(result); } }
public void TestFinished(TestResult result) { testRecord.CompleteTest(result); string logFileName = GetLogFileName(testRecord); LogTestResult(logFileName, testRecord); testRecord.TestTime = result.Time; }
private object RunVoidAsyncMethod(TestResult testResult) { var previousContext = SynchronizationContext.Current; var currentContext = new AsyncSynchronizationContext(); SynchronizationContext.SetSynchronizationContext(currentContext); try { object result = base.RunTestMethod(testResult); try { currentContext.WaitForPendingOperationsToComplete(); } catch (Exception e) { throw new NUnitException("Rethrown", e); } return result; } finally { SynchronizationContext.SetSynchronizationContext(previousContext); } }
TestResult RunTest(EventListener listener) { listener.TestStarted(base.TestName); TestResult nunitTestResult = new TestResult(this); if (_pendingException != null) { nunitTestResult.Failure(_pendingException.Message, _pendingException.StackTrace, FailureSite.Test); } else if (RunState == RunState.NotRunnable) { nunitTestResult.SetResult(ResultState.NotRunnable, IgnoreReason, "", FailureSite.Test); } else { var testResult = SpecificationRunner.RunTest(this._testContext, new List<string>()); NativeTestResult.ApplyToNunitResult(testResult, nunitTestResult); } listener.TestFinished(nunitTestResult); return nunitTestResult; }
public void TestFinished(TestResult testResult) { switch (testResult.ResultState) { case ResultState.Error: case ResultState.Failure: case ResultState.Cancelled: var result = new AutoTest.TestRunners.Shared.Results.TestResult("NUnit", currentAssembly, getFixture(testResult.Test.TestName.FullName), testResult.Time * 1000, testResult.Test.TestName.FullName, TestRunners.Shared.Results.TestState.Failed, testResult.Message); result.AddStackLines(getStackLines(testResult).ToArray()); _results.Add(result); break; case ResultState.Success: _results.Add(new AutoTest.TestRunners.Shared.Results.TestResult("NUnit", currentAssembly, getFixture(testResult.Test.TestName.FullName), testResult.Time * 1000, testResult.Test.TestName.FullName, TestRunners.Shared.Results.TestState.Passed, testResult.Message)); break; case ResultState.Inconclusive: case ResultState.Ignored: case ResultState.Skipped: case ResultState.NotRunnable: var ignoreResult = new AutoTest.TestRunners.Shared.Results.TestResult("NUnit", currentAssembly, getFixture(testResult.Test.TestName.FullName), testResult.Time * 1000, testResult.Test.TestName.FullName, TestRunners.Shared.Results.TestState.Ignored, testResult.Message); ignoreResult.AddStackLines(getStackLines(testResult).ToArray()); _results.Add(ignoreResult); break; } }
public VSTestResult ConvertTestResult(NUnitTestResult result) { TestCase ourCase = GetCachedTestCase(result.Test.TestName.UniqueName); if (ourCase == null) return null; VSTestResult ourResult = new VSTestResult(ourCase) { DisplayName = ourCase.DisplayName, Outcome = ResultStateToTestOutcome(result.ResultState), Duration = TimeSpan.FromSeconds(result.Time) }; // TODO: Remove this when NUnit provides a better duration if (ourResult.Duration == TimeSpan.Zero && (ourResult.Outcome == TestOutcome.Passed || ourResult.Outcome == TestOutcome.Failed)) ourResult.Duration = TimeSpan.FromTicks(1); ourResult.ComputerName = Environment.MachineName; // TODO: Stuff we don't yet set // StartTime - not in NUnit result // EndTime - not in NUnit result // Messages - could we add messages other than the error message? Where would they appear? // Attachments - don't exist in NUnit if (result.Message != null) ourResult.ErrorMessage = GetErrorMessage(result); if (!string.IsNullOrEmpty(result.StackTrace)) { string stackTrace = StackTraceFilter.Filter(result.StackTrace); ourResult.ErrorStackTrace = stackTrace; } return ourResult; }
public void TestFinished(TestResult result) { if (ConfigReader.DefaultProvider.AllConfiguration.NUnitAddin.ReportBack) { Communicator.ReportResultToSpiraTeam(result); } }
public XmlResultVisitor( TextWriter writer, TestResult result ) { this.memoryStream = new MemoryStream(); this.writer = writer; this.xmlWriter = new XmlTextWriter( new StreamWriter( memoryStream, System.Text.Encoding.UTF8 ) ); Initialize( result ); }
public new void SuiteFinished(TestResult suiteResult) { if ( --level == 0) { Trace.WriteLine( "############################################################################" ); if (messages.Count == 0) { Trace.WriteLine( "############## S U C C E S S #################" ); } else { Trace.WriteLine( "############## F A I L U R E S #################" ); foreach ( string s in messages ) { Trace.WriteLine(s); } } Trace.WriteLine( "############################################################################" ); Trace.WriteLine( "Executed tests : " + testRunCount ); Trace.WriteLine( "Ignored tests : " + testIgnoreCount ); Trace.WriteLine( "Failed tests : " + failureCount ); Trace.WriteLine( "Unhandled exceptions : " + unhandledExceptions.Count); Trace.WriteLine( "Total time : " + suiteResult.Time + " seconds" ); Trace.WriteLine( "############################################################################"); } }
public override void DoFixtureSetUp(TestResult suiteResult) { try { _fixture.FixtureSetup(); Status = SetUpState.SetUpComplete; } catch (Exception ex) { if (ex is NunitException || ex is TargetInvocationException) ex = ex.InnerException; if (testFramework.IsIgnoreException(ex)) { ShouldRun = false; suiteResult.NotRun(ex.Message); suiteResult.StackTrace = ex.StackTrace; IgnoreReason = ex.Message; } else { suiteResult.Failure(ex.Message, ex.StackTrace); Status = SetUpState.SetUpFailed; } } finally { if (testFramework != null) suiteResult.AssertCount = testFramework.GetAssertCount(); } }
public override TestResult Run(EventListener listener, ITestFilter filter) { listener.TestStarted(base.TestName); long ticks = DateTime.Now.Ticks; var testResult = new TestResultShim(); Exception existingError = null; _globalSetup.PrepareForTestPosition(Position, out existingError); if (existingError != null) { TestResultUtil.Error(testResult, TestExtensions.GetMultilineName(this), existingError, null, TestResultShim.Site.SetUp); } else { List<string> traceMessages = null; try { RunTestMethod(testResult, out traceMessages); } catch (Exception e) { var globalTraceMessages = _globalSetup.GetTraceMessages(); TestResultUtil.Error(testResult, TestExtensions.GetMultilineName(this), e, globalTraceMessages.Concat(traceMessages)); } } var nunitTestResult = new TestResult(this); NativeTestResult.ApplyToNunitResult(testResult, nunitTestResult); nunitTestResult.Time = ((DateTime.Now.Ticks - ticks)) / 10000000.0; listener.TestFinished(nunitTestResult); return nunitTestResult; }
// ---------------------------------------------------------------------- private void AppendResult( TestResult testResult ) { if ( testResult.IsSuccess ) { return; } if ( testResult.Results == null ) { if ( testResult.IsFailure ) { failedTests.Add( string.Format( "{0}: {1}", testResult.FullName, testResult.Message ) ); if ( !string.IsNullOrEmpty( testResult.StackTrace ) ) { failedTests.Add( testResult.StackTrace ); } } if ( testResult.IsError ) { errorTests.Add( string.Format( "{0}: {1}", testResult.FullName, testResult.Message ) ); if ( !string.IsNullOrEmpty( testResult.StackTrace ) ) { errorTests.Add( testResult.StackTrace ); } } } else { foreach ( TestResult childResult in testResult.Results ) { AppendResult( childResult ); } } }
/// <summary> /// Saves the TestResult as xml to the specified path. /// </summary> /// <param name="result">The test result to be saved.</param> /// <param name="outputXmlPath">The output xml path.</param> private static void SaveXmlOutput(TestResult result, string outputXmlPath) { if (!string.IsNullOrEmpty(outputXmlPath)) { var writer = new XmlResultWriter(outputXmlPath); writer.SaveTestResult(result); } }
public void RunFinished(TestResult testResult) { var dialog = new TestReportDialog(_nrOk, _nrFailed, _resultsAL); TestReportDialog.ShowHelpButton(false); dialog.ShowAll(); dialog.Run(); dialog.Destroy(); }
private void AddNode( TestResult result ) { TreeNode node = new TreeNode(result.Name); TreeNode reasonNode = new TreeNode("Reason: " + result.Message); node.Nodes.Add(reasonNode); Nodes.Add( node ); }
/// <summary> /// Creates an instance of TestResultViewerViewModel. /// </summary> /// <param name="rootResult">The root of test result object.</param> public TestResultViewerViewModel(TestResult rootResult, string resultFile) { TestResults = new ObservableCollection<TestItemViewModel>(); ResultFileName = resultFile; WalkTheTestResult(rootResult); }
/// <summary> /// Saves the TestResult as xml to the specified path. /// </summary> /// <param name="result">The test result to be saved.</param> /// <param name="textWriter">The text writer.</param> public static void SaveXmlOutput(TestResult result, TextWriter textWriter) { if (textWriter != null) { var writer = new XmlResultWriter(textWriter); writer.SaveTestResult(result); } }
public void DisplayResults( TestResult results ) { notRunTree.BeginUpdate(); results.Accept(this); notRunTree.EndUpdate(); if( testDetails.Items.Count > 0 ) testDetails.SelectedIndex = 0; }
public void RunFinished(TestResult result) { Console.WriteLine("\nNumber of tests: "+count+" Failed: "+failed+" Skipped: "+skipped); if(result.IsSuccess) { Console.WriteLine("ALL OK"); } else { Console.WriteLine("TESTRUN FAILED: "+result.Message); } }
public void RunFinished(NUnit.Core.TestResult testResult) { this.testResult = testResult; try { this.SaveLastResult( Path.Combine(Path.GetDirectoryName(this.TestFileName), "TestResult.xml")); events.FireRunFinished(testResult); } catch (Exception ex) { this.lastException = ex; events.FireRunFinished(ex); } }
public void TestFinished(NUnit.Core.TestResult testResult) { ++this.s.TestCount; switch (testResult.ResultState) { case ResultState.Inconclusive: ++this.s.InconclusiveCount; break; case ResultState.Success: ++this.s.PassCount; break; case ResultState.NotRunnable: ++this.s.InvalidCount; break; case ResultState.Skipped: ++this.s.SkipCount; break; case ResultState.Ignored: ++this.s.IgnoreCount; break; case ResultState.Failure: ++this.s.FailureCount; FormatStackTrace(testResult); break; case ResultState.Error: ++this.s.ErrorCount; FormatStackTrace(testResult); break; case ResultState.Cancelled: ++this.s.FailureCount; FormatStackTrace(testResult); break; } if (this._messageSubscribeAdapter != null) { this._messageSubscribeAdapter.TestFinished(testResult); } this.currentTestName = string.Empty; }
private void FormatStackTrace(NUnit.Core.TestResult testResult) { this.outWriter.WriteLine(string.Format("{0}) {1} :", this.s.FailureCount, testResult.Test.TestName.FullName)); this.outWriter.WriteLine(testResult.Message.Trim(Environment.NewLine.ToCharArray())); string filteredStackTrace = StackTraceFilter.Filter(testResult.StackTrace); if (filteredStackTrace != null && filteredStackTrace != string.Empty) { foreach (string stackTraceLines in filteredStackTrace.Split(Environment.NewLine.ToCharArray())) { if (stackTraceLines != string.Empty) { this.outWriter.WriteLine(string.Format("at\n{0}", Regex.Replace(stackTraceLines.Trim(), ".* in (.*):line (.*)", "$1($2)"))); } } } }
public void SetUp() { MethodInfo fakeTestMethod = GetType().GetMethod("FakeTestMethod", BindingFlags.Instance | BindingFlags.NonPublic); fakeNUnitTest = new NUnitTestMethod(fakeTestMethod); fakeNUnitResult = new NUnitTestResult(fakeNUnitTest); fakeNUnitResult.SetResult(ResultState.Success, "It passed!", null); fakeNUnitResult.Time = 1.234; testLog = new FakeFrameworkHandle(); testConverter = new TestConverter(new TestLogger(), ThisAssemblyPath); testConverter.ConvertTestCase(fakeNUnitTest); Assert.NotNull(testConverter.GetCachedTestCase(fakeNUnitTest.TestName.UniqueName)); listener = new NUnitEventListener(testLog, testConverter); }
public VSTestResult ConvertTestResult(NUnitTestResult result) { TestCase ourCase = GetCachedTestCase(result.Test.TestName.UniqueName); if (ourCase == null) { return(null); } VSTestResult ourResult = new VSTestResult(ourCase) { DisplayName = ourCase.DisplayName, Outcome = ResultStateToTestOutcome(result.ResultState), Duration = TimeSpan.FromSeconds(result.Time) }; // TODO: Remove this when NUnit provides a better duration if (ourResult.Duration == TimeSpan.Zero && (ourResult.Outcome == TestOutcome.Passed || ourResult.Outcome == TestOutcome.Failed)) { ourResult.Duration = TimeSpan.FromTicks(1); } ourResult.ComputerName = Environment.MachineName; // TODO: Stuff we don't yet set // StartTime - not in NUnit result // EndTime - not in NUnit result // Messages - could we add messages other than the error message? Where would they appear? // Attachments - don't exist in NUnit if (result.Message != null) { ourResult.ErrorMessage = GetErrorMessage(result); } if (!string.IsNullOrEmpty(result.StackTrace)) { string stackTrace = StackTraceFilter.Filter(result.StackTrace); ourResult.ErrorStackTrace = stackTrace; } return(ourResult); }
public void TestFinished(TestCaseResult testResult) { if (testResult.Executed) { testRunCount++; if (testResult.IsFailure) { failureCount++; Console.Write("F"); if (debugger) { #if NUNIT_2_5 messages.Add(string.Format("{0}) {1} :", failureCount, testResult.Test.TestName.FullName)); #else messages.Add(string.Format("{0}) {1} :", failureCount, testResult.Test.FullName)); #endif messages.Add(testResult.Message.Trim(Environment.NewLine.ToCharArray())); string stackTrace = StackTraceFilter.Filter(testResult.StackTrace); string[] trace = stackTrace.Split(System.Environment.NewLine.ToCharArray()); foreach (string s in trace) { if (s != string.Empty) { string link = Regex.Replace(s.Trim(), @".* in (.*):line (.*)", "$1($2)"); messages.Add(string.Format("at\n{0}", link)); } } } } } else { testIgnoreCount++; Console.Write("N"); } currentTestName = string.Empty; }
public void CanMakeTestResultFromNUnitTestResult() { // This should put the TestCase in the cache var cachedTestCase = testConverter.ConvertTestCase(fakeNUnitTest); var nunitResult = new NUnitTestResult(fakeNUnitTest); nunitResult.SetResult(ResultState.Success, "It passed!", null); nunitResult.Time = 1.234; var testResult = testConverter.ConvertTestResult(nunitResult); var testCase = testResult.TestCase; Assert.That(testCase, Is.SameAs(cachedTestCase)); CheckTestCase(testCase); Assert.That(testResult.Outcome, Is.EqualTo(TestOutcome.Passed)); Assert.That(testResult.ErrorMessage, Is.EqualTo("It passed!")); Assert.That(testResult.Duration, Is.EqualTo(TimeSpan.FromSeconds(1.234))); }
private void GetTestResult(NUnit.Core.TestResult result, ref TestRail.TestResult tc, ref string failureTestCases) { string[] featuretags = FeatureContext.Current.FeatureInfo.Tags; string[] tagstr = ScenarioContext.Current.ScenarioInfo.Tags; if (result.ResultState == ResultState.Ignored) { return; } string result_status = string.Empty; string result_message = string.Empty; string result_stackTrace = string.Empty; tc = new TestRail.TestResult(); foreach (string str in tagstr) { string tagname = str.Split(':')[0].ToUpper(); string tagvalue = str.Substring(str.IndexOf(str.Split(':')[1])); switch (tagname) { case "CASEID": tc.Case_id = tagvalue; break; case "PRIORITY": tc.Priority = tagvalue; break; case "MILESTONE": tc.MileStone = tagvalue; break; case "TYPE": tc.Type = tagvalue; break; // case "SUITENAME": tc.Suite_Name = tagvalue; break; } } tc.Suite_Id = tru.GetSuiteIdByCaseId(tc.Case_id); tc.Result_status = result.ResultState.ToString(); tc.Result_message = output; if (!result.IsSuccess) { //log failure test cases failureTestCases += "caseid:" + tc.Case_id + ","; } }
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()); }
protected override void DoOneTimeTearDown(TestResult suiteResult) { base.DoOneTimeTearDown(suiteResult); suiteResult.AssertCount += NUnitFramework.GetAssertCount(); }
public void TestFinished(NUnit.Core.TestResult result) { testRunnerEventListener.TestFinished(result.UnitTestResult()); }
public void SuiteFinished(NUnit.Core.TestResult result) { }
public void TestFinished(NUnit.Core.TestResult result) { m_TestRunnerEventListener.TestFinished(result.UnitTestResult(m_testLog.ToString())); m_testLog = null; }
public void RunFinished(NUnit.Core.TestResult result) { testRunnerEventListener.RunFinished(); }
public virtual void DoSetUp(TestResult suiteResult) { }
public void BeginRun(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel) { testResult = this.Run(listener, filter, tracing, logLevel); }
public void TestFinished(NUnit.Core.TestResult result) { TestRail.TestResult tr = null; string testType = result.Test.TestType; try { GetTestResult(result, ref tr, ref failureTestCases); //update automation type to specflow after test finished TestRail.Case cse = tru.GetCaseByCaseId(tr.Case_id); if (cse.AutomationType != "4") { tru.UpdateAutomationTypeToSpecFlow(tr.Case_id); } suiteid = tr.Suite_Id; if (result.Test.Categories.Count == 0) { if (result.IsSuccess) { testcaseres.Add(true); } else { testcaseres.Add(false); } results.Add(result.FullName, tr.Result_status.ToString()); caseid = tr.Case_id; } if (!result.IsSuccess) { AddLog(Path.Combine(logPath, planName, runstarttime + "." + planName + "_FailureTestCases.log"), result.FullName); } List <Run> runs = tru.GetRunIdsByProjectNameAndPlanNameAndSuiteId(project, planName, tr.Suite_Id); // List<string> runids = GetTestRunsByPlanNameAndSuiteId(project, planName, tr.Suite_Id, tr.Case_id); #region //if (runname.Trim() == string.Empty) //{ // foreach (Run run in runs) // { // TestRail.Suite suite = null; // TestRail.Case cs = null; // TestRail.LocalTestCase ltc = null; // output = string.Empty; // tr.RunId = run.Id; // if (bAddTestResult) // { // tru.AddTestResult(tr); // } // if (btestCaseSync && result.Test.Categories.Count == 1) // { // bool updateresult = SyncTestcase(tr, ref ltc, ref cs, ref suite); // if (updateresult) // { // string message = "Case update success, " + "Suite:" + suite.SuiteName + ", Case: " + tr.Case_id + ", Title:" + ltc.Title; // AddLog(Path.Combine(logPath, planName, runstarttime + "." + planName + "_CaseUpdate.log"), message); // } // } // } //} //else //{ // foreach (Run run in runs) // { // if (run.RunName == runname.Trim()) // { // TestRail.Suite suite = null; // TestRail.Case cs = null; // TestRail.LocalTestCase ltc = null; // output = string.Empty; // tr.RunId = run.Id; // if (bAddTestResult) // { // tru.AddTestResult(tr); // } // if (btestCaseSync && result.Test.Categories.Count == 1) // { // bool updateresult = SyncTestcase(tr, ref ltc, ref cs, ref suite); // if (updateresult) // { // string message = "Case update success, " + "Suite:" + suite.SuiteName + ", Case: " + tr.Case_id + ", Title:" + ltc.Title; // AddLog(Path.Combine(logPath, planName, runstarttime + "." + planName + "_CaseUpdate.log"), message); // } // } // } // } //} #endregion foreach (Run run in runs) { if (runname.Trim() == string.Empty) { TestRail.Suite suite = null; TestRail.Case cs = null; TestRail.LocalTestCase ltc = null; output = string.Empty; tr.RunId = run.Id; if (bAddTestResult) { tru.AddTestResult(tr); } if (btestCaseSync && result.Test.Categories.Count == 1) { bool updateresult = SyncTestcase(tr, ref ltc, ref cs, ref suite); if (updateresult) { string message = "Case update success, " + "Suite:" + suite.SuiteName + ", Case: " + tr.Case_id + ", Title:" + ltc.Title; AddLog(Path.Combine(logPath, planName, runstarttime + "." + planName + "_CaseUpdate.log"), message); } } } else { if (run.RunName == runname.Trim()) { TestRail.Suite suite = null; TestRail.Case cs = null; TestRail.LocalTestCase ltc = null; output = string.Empty; tr.RunId = run.Id; if (bAddTestResult) { tru.AddTestResult(tr); } if (btestCaseSync && result.Test.Categories.Count == 1) { bool updateresult = SyncTestcase(tr, ref ltc, ref cs, ref suite); if (updateresult) { string message = "Case update success, " + "Suite:" + suite.SuiteName + ", Case: " + tr.Case_id + ", Title:" + ltc.Title; AddLog(Path.Combine(logPath, planName, runstarttime + "." + planName + "_CaseUpdate.log"), message); } } } } } } catch (Exception ex) { caseid = tr.Case_id; string errorMsg = result.FullName + ":\r\n" + "caseid:" + caseid + "\r\n" + ex.Message + "\r\n" + ex.StackTrace + "\r\n"; AddLog(Path.Combine(logPath, planName, runstarttime + "." + planName + "_ErrorMsg.log"), errorMsg); throw ex; } }
public void SuiteFinished(TestResult result) { }
public virtual void DoTearDown(TestResult suiteResult) { }
public void SuiteFinished(NUnit.Core.TestResult result) { string testType = result.Test.TestType; if (testType == "ParameterizedTest") { finalres = testcaseres[0]; foreach (bool res in testcaseres) { finalres &= res; } TestRail.TestResult tr = new TestRail.TestResult(); tr.Case_id = caseid; if (finalres) { tr.Result_status = "Success"; tr.Result_message = "Final result -Success: \r\n"; } else { tr.Result_status = "Failure"; tr.Result_message = "Final result -Failure: \r\n"; } foreach (KeyValuePair <string, string> res in results) { tr.Result_message += res.Key + ":" + res.Value + "\r\n"; } try { // List<string> runids = GetTestRunsByPlanNameAndSuiteId(project, planName, suiteid, tr.Case_id); List <Run> runs = tru.GetRunIdsByProjectNameAndPlanNameAndSuiteId(project, planName, suiteid); foreach (Run run in runs) { if (runname.Trim() == string.Empty) { tr.RunId = run.Id; if (bAddTestResult) { tru.AddTestResult(tr); } if (btestCaseSync) { TestRail.Suite suite = null; TestRail.Case cs = null; TestRail.LocalTestCase ltc = null; bool updateresult = SyncTestcase(tr, ref ltc, ref cs, ref suite); if (updateresult) { string message = "Case update success, " + "Suite:" + suite.SuiteName + ", Case: " + tr.Case_id + ", Title:" + ltc.Title; AddLog(Path.Combine(logPath, planName, runstarttime + "." + planName + "_CaseUpdate.log"), message); } } } else { if (run.RunName == runname.Trim()) { tr.RunId = run.Id; if (bAddTestResult) { tru.AddTestResult(tr); } if (btestCaseSync) { TestRail.Suite suite = null; TestRail.Case cs = null; TestRail.LocalTestCase ltc = null; bool updateresult = SyncTestcase(tr, ref ltc, ref cs, ref suite); if (updateresult) { string message = "Case update success, " + "Suite:" + suite.SuiteName + ", Case: " + tr.Case_id + ", Title:" + ltc.Title; AddLog(Path.Combine(logPath, planName, runstarttime + "." + planName + "_CaseUpdate.log"), message); } } } } } } catch (Exception ex) { caseid = tr.Case_id; string errorMsg = result.FullName + ":\r\n" + "caseid:" + caseid + "\r\n" + ex.Message + "\r\n" + ex.StackTrace + "\r\n"; AddLog(Path.Combine(logPath, planName, runstarttime + "." + planName + "_ErrorMsg.log"), errorMsg); throw ex; } } results.Clear(); testcaseres.Clear(); }
void EventListener.TestFinished(NUnit.Core.TestResult result) { OnTestFinished(new TestSummary { Result = result.ResultState.ToTestResult() }); }
private void UpdateTestResults(NUnit.Core.TestResult result) { ToUnitTestResult(result); }
public void RunFinished(NUnit.Core.TestResult result) { OnTestRunFinished(new TestSummary { Result = result.ResultState.ToTestResult() }); }
protected override void DoOneTimeSetUp(TestResult suiteResult) { base.DoOneTimeSetUp(suiteResult); suiteResult.AssertCount = NUnitFramework.GetAssertCount();; }
public void RunFinished(NUnit.Core.TestResult testResult) { this.testResult = testResult; events.FireRunFinished(testResult); }