/// <summary> /// Creates an aggregate root test result. /// </summary> /// <param name="runId">The test run id.</param> /// <param name="test">The test element.</param> /// <returns>The test result.</returns> public static GallioTestResult CreateAggregateRootTestResult(Guid runId, ITestElement test) { var result = new GallioTestResult(runId, test); result.Outcome = VSTestOutcome.Pending; return(result); }
private static GallioTestResult CreateTestResult(TestStepRun run, Guid runId, ITestElement test, bool includeTestStepRunXml) { var result = new GallioTestResult(runId, test); result.TestName = run.Step.FullName; result.Outcome = GetOutcome(run.Result.Outcome); foreach (StructuredStream stream in run.TestLog.Streams) { string contents = stream.ToString(); if (stream.Name == MarkupStreamNames.DebugTrace) result.DebugTrace += contents; else if (stream.Name == MarkupStreamNames.ConsoleOutput) result.StdOut += contents; else if (stream.Name == MarkupStreamNames.ConsoleError) result.StdErr += contents; else if (stream.Name == MarkupStreamNames.Failures || stream.Name == MarkupStreamNames.Warnings) result.ErrorMessage += contents; else result.DebugTrace += contents; } result.SetTimings(run.StartTime, run.EndTime, run.Result.Duration); if (includeTestStepRunXml) result.TestStepRunXml = TestStepRunToXml(run); foreach (TestStepRun childRun in run.Children) result.AddInnerResult(CreateTestResult(childRun, runId, test, false)); return result; }
/// <summary> /// Adds a test result as an inner result. /// </summary> /// <param name="testResult">The test result to add.</param> public void AddInnerResult(GallioTestResult testResult) { int oldLength = m_innerResults.Length; Array.Resize(ref m_innerResults, oldLength + 1); m_innerResults[oldLength] = testResult; }
/// <summary> /// Gets the test step runs associated with a test result. /// </summary> public static IList <TestStepRun> GetTestStepRuns(GallioTestResult result) { List <TestStepRun> runs = new List <TestStepRun>(); if (result.IsAggregateRoot) { foreach (GallioTestResult innerResult in result.InnerResults) { TestStepRun run = GetTestStepRun(innerResult); if (run != null) { runs.Add(run); } } } else { TestStepRun run = GetTestStepRun(result); if (run != null) { runs.Add(run); } } return(runs); }
/// <summary> /// Sets the list of inner results. /// </summary> /// <param name="testResults">The test results to set.</param> public void SetInnerResults(IList <GallioTestResult> testResults) { m_innerResults = new GallioTestResult[testResults.Count]; for (int i = 0; i < testResults.Count; i++) { m_innerResults[i] = testResults[i]; } }
/// <summary> /// Merges Gallio test results. /// </summary> /// <param name="inMemory">The currently available test result, or null if none.</param> /// <param name="fromTheWire">The test result to add, or null if none.</param> /// <returns>The merged test result.</returns> public static GallioTestResult Merge(GallioTestResult inMemory, GallioTestResult fromTheWire) { if (fromTheWire == null) { return(inMemory); } if (inMemory == null) { return(fromTheWire); } List <GallioTestResult> combinedResults = new List <GallioTestResult>(); VSTestOutcome combinedOutcome = VSTestOutcome.Pending; CombineResults(combinedResults, ref combinedOutcome, inMemory); CombineResults(combinedResults, ref combinedOutcome, fromTheWire); GallioTestResult result; if (combinedResults.Count == 1) { result = combinedResults[0]; } else { result = CreateAggregateRootTestResult(inMemory.Id.RunId, inMemory.Test); if (combinedResults.Count != 0) { result.SetInnerResults(combinedResults); DateTime startTime = DateTime.MaxValue; DateTime endTime = DateTime.MinValue; TimeSpan duration = TimeSpan.Zero; foreach (GallioTestResult innerResult in combinedResults) { if (innerResult.StartTime < startTime) { startTime = innerResult.StartTime; } if (innerResult.EndTime > endTime) { endTime = innerResult.EndTime; } duration += innerResult.Duration; } result.SetTimings(startTime, endTime, duration); } } result.Outcome = combinedOutcome; return(result); }
/// <summary> /// Closes the test result viewer for the specified Gallio result. /// </summary> /// <param name="result">The test result message.</param> public void CloseResultViewer(TestResultMessage result) { if (!TipShellExtension.IsInitialized) { return; } GallioTestResult gallioResult = result as GallioTestResult; if (gallioResult != null) { toolWindowManager.CloseToolWindow(GetWindowId(gallioResult)); } }
/// <summary> /// Invokes the test result viewer for the specified Gallio test. /// </summary> /// <param name="result">The result of the unit test.</param> public void InvokeResultViewer(TestResultMessage result) { if (!TipShellExtension.IsInitialized) { return; } GallioTestResult gallioResult = result as GallioTestResult; if (gallioResult != null) { TestResultWindow window = new TestResultWindow(gallioResult); toolWindowManager.OpenToolWindow(GetWindowId(gallioResult), window); } }
private static GallioTestResult CreateTestResult(TestStepRun run, Guid runId, ITestElement test, bool includeTestStepRunXml) { var result = new GallioTestResult(runId, test); result.TestName = run.Step.FullName; result.Outcome = GetOutcome(run.Result.Outcome); foreach (StructuredStream stream in run.TestLog.Streams) { string contents = stream.ToString(); if (stream.Name == MarkupStreamNames.DebugTrace) { result.DebugTrace += contents; } else if (stream.Name == MarkupStreamNames.ConsoleOutput) { result.StdOut += contents; } else if (stream.Name == MarkupStreamNames.ConsoleError) { result.StdErr += contents; } else if (stream.Name == MarkupStreamNames.Failures || stream.Name == MarkupStreamNames.Warnings) { result.ErrorMessage += contents; } else { result.DebugTrace += contents; } } result.SetTimings(run.StartTime, run.EndTime, run.Result.Duration); if (includeTestStepRunXml) { result.TestStepRunXml = TestStepRunToXml(run); } foreach (TestStepRun childRun in run.Children) { result.AddInnerResult(CreateTestResult(childRun, runId, test, false)); } return(result); }
protected override void Initialize() { foreach (ITestElement testElement in runContext.RunConfig.TestElements) { GallioTestElement gallioTestElement = testElement as GallioTestElement; if (gallioTestElement != null) { testElementsById.Add(gallioTestElement.GallioTestId, gallioTestElement); } } Events.RunStarted += delegate(object sender, RunStartedEventArgs e) { // Change the status of all tests to Started so that all Gallio tests look "In Progress". // If we didn't do this, then there would be one "In Progress" test (the first one started) // and a whole bunch of "Pending" tests. Visual Studio assumes that it controls the order // of execution of all tests but it cannot. Behind the scenes we hijack the order of execution // when Visual Studio starts the first test. Of course that test might not actually run // first but it will seem to be "In Progress" just the same. Instead of misleading the user // as to which test is currently running, we just make them all look "In Progress" at once. Ugh. foreach (GallioTestElement gallioTestElement in testElementsById.Values) { TestStateEvent ev = new TestStateEvent(runContext.RunConfig.TestRun.Id, gallioTestElement.ExecutionId.Id, TestState.Started); runContext.ResultSink.AddResult(ev); } }; Events.TestStepFinished += delegate(object sender, TestStepFinishedEventArgs e) { // Submit a GallioTestResult for each primary run of a test case. // In the case of data-driven tests, we may submit multiple results that will later be merged. if (e.TestStepRun.Step.IsPrimary) { GallioTestElement gallioTestElement = GetTestElement(e.Test); if (gallioTestElement != null) { GallioTestResult result = GallioTestResultFactory.CreateTestResult(e.TestStepRun, runContext.RunConfig.TestRun.Id, gallioTestElement); runContext.ResultSink.AddResult(result); } } }; }
public override TestResult MergeResults(TestResult inMemory, TestResultMessage fromTheWire) { // The only type of message we should receive from the wire is a GallioTestResult. // However, we can receive multiple results in the case where the test is data-driven // so we need to merge them. GallioTestResult gallioInMemory = inMemory as GallioTestResult; if (gallioInMemory == null && inMemory != null) { gallioInMemory = new GallioTestResult(gallioInMemory); } GallioTestResult gallioFromTheWire = fromTheWire as GallioTestResult; if (gallioFromTheWire == null && fromTheWire is TestResult) { gallioFromTheWire = new GallioTestResult((TestResult)fromTheWire); } return(GallioTestResultFactory.Merge(gallioInMemory, gallioFromTheWire)); }
/// <summary> /// Gets a test step run from a given test result. /// </summary> /// <param name="result">A test result.</param> /// <returns>A test step run instance.</returns> public static TestStepRun GetTestStepRun(GallioTestResult result) { TestStepRun run = TestStepRunFromXml(result.TestStepRunXml); #if VS100_OR_NEWER if (run != null) { foreach (CollectorDataEntry collectorEntry in result.CollectorDataEntries) { if (collectorEntry != null) { var attachmentData = CreateAttachmentData(collectorEntry); if (attachmentData != null) { run.TestLog.Attachments.Add(attachmentData.ToAttachmentData()); } } } } #endif return(run); }
private static void CombineResults(List<GallioTestResult> combinedResults, ref VSTestOutcome combinedOutcome, GallioTestResult source) { CombineOutcome(ref combinedOutcome, source.Outcome); if (source.IsAggregateRoot) { foreach (GallioTestResult innerResult in source.InnerResults) { combinedResults.Add(innerResult); CombineOutcome(ref combinedOutcome, innerResult.Outcome); } } else { combinedResults.Add(source); } }
private GallioTestResult(GallioTestResult result) : base(result) { testStepRunXml = result.testStepRunXml; }
/// <summary> /// Creates an aggregate root test result. /// </summary> /// <param name="runId">The test run id.</param> /// <param name="test">The test element.</param> /// <returns>The test result.</returns> public static GallioTestResult CreateAggregateRootTestResult(Guid runId, ITestElement test) { var result = new GallioTestResult(runId, test); result.Outcome = VSTestOutcome.Pending; return result; }
/// <summary> /// Gets the test step runs associated with a test result. /// </summary> public static IList<TestStepRun> GetTestStepRuns(GallioTestResult result) { List<TestStepRun> runs = new List<TestStepRun>(); if (result.IsAggregateRoot) { foreach (GallioTestResult innerResult in result.InnerResults) { TestStepRun run = GetTestStepRun(innerResult); if (run != null) runs.Add(run); } } else { TestStepRun run = GetTestStepRun(result); if (run != null) runs.Add(run); } return runs; }
private static void CombineResults(List <GallioTestResult> combinedResults, ref VSTestOutcome combinedOutcome, GallioTestResult source) { CombineOutcome(ref combinedOutcome, source.Outcome); if (source.IsAggregateRoot) { foreach (GallioTestResult innerResult in source.InnerResults) { combinedResults.Add(innerResult); CombineOutcome(ref combinedOutcome, innerResult.Outcome); } } else { combinedResults.Add(source); } }
/// <summary> /// Merges Gallio test results. /// </summary> /// <param name="inMemory">The currently available test result, or null if none.</param> /// <param name="fromTheWire">The test result to add, or null if none.</param> /// <returns>The merged test result.</returns> public static GallioTestResult Merge(GallioTestResult inMemory, GallioTestResult fromTheWire) { if (fromTheWire == null) return inMemory; if (inMemory == null) return fromTheWire; List<GallioTestResult> combinedResults = new List<GallioTestResult>(); VSTestOutcome combinedOutcome = VSTestOutcome.Pending; CombineResults(combinedResults, ref combinedOutcome, inMemory); CombineResults(combinedResults, ref combinedOutcome, fromTheWire); GallioTestResult result; if (combinedResults.Count == 1) { result = combinedResults[0]; } else { result = CreateAggregateRootTestResult(inMemory.Id.RunId, inMemory.Test); if (combinedResults.Count != 0) { result.SetInnerResults(combinedResults); DateTime startTime = DateTime.MaxValue; DateTime endTime = DateTime.MinValue; TimeSpan duration = TimeSpan.Zero; foreach (GallioTestResult innerResult in combinedResults) { if (innerResult.StartTime < startTime) startTime = innerResult.StartTime; if (innerResult.EndTime > endTime) endTime = innerResult.EndTime; duration += innerResult.Duration; } result.SetTimings(startTime, endTime, duration); } } result.Outcome = combinedOutcome; return result; }
private static string GetWindowId(GallioTestResult result) { return("Gallio.VisualStudio.Tip.TestResult:" + result.Id.TestId); }
/// <summary> /// Sets the list of inner results. /// </summary> /// <param name="testResults">The test results to set.</param> public void SetInnerResults(IList<GallioTestResult> testResults) { m_innerResults = new GallioTestResult[testResults.Count]; for (int i = 0; i < testResults.Count; i++) m_innerResults[i] = testResults[i]; }
private static string GetWindowId(GallioTestResult result) { return "Gallio.VisualStudio.Tip.TestResult:" + result.Id.TestId; }
public override TestResult MergeResults(TestResult inMemory, TestResultMessage fromTheWire) { // The only type of message we should receive from the wire is a GallioTestResult. // However, we can receive multiple results in the case where the test is data-driven // so we need to merge them. GallioTestResult gallioInMemory = inMemory as GallioTestResult; if (gallioInMemory == null && inMemory != null) gallioInMemory = new GallioTestResult(gallioInMemory); GallioTestResult gallioFromTheWire = fromTheWire as GallioTestResult; if (gallioFromTheWire == null && fromTheWire is TestResult) gallioFromTheWire = new GallioTestResult((TestResult)fromTheWire); return GallioTestResultFactory.Merge(gallioInMemory, gallioFromTheWire); }
/// <summary> /// Gets a test step run from a given test result. /// </summary> /// <param name="result">A test result.</param> /// <returns>A test step run instance.</returns> public static TestStepRun GetTestStepRun(GallioTestResult result) { TestStepRun run = TestStepRunFromXml(result.TestStepRunXml); #if VS100_OR_NEWER if (run != null) { foreach (CollectorDataEntry collectorEntry in result.CollectorDataEntries) { if (collectorEntry != null) { var attachmentData = CreateAttachmentData(collectorEntry); if(attachmentData != null) { run.TestLog.Attachments.Add(attachmentData.ToAttachmentData()); } } } } #endif return run; }