public void ConvertMemoryLeakToVSTestResult()
{
LogEntryMemoryLeak leak = new LogEntryMemoryLeak();
leak.LeakLineNumber = 32;
leak.LeakMemoryAllocationNumber = 836;
leak.LeakLeakedDataContents = " Data: <`- Leak... > 60 2D BD 00 4C 65 61 6B 2E 2E 2E 00 CD CD CD CD ";
leak.LeakSourceFilePath = @"C:\boostunittestsample.cpp";
leak.LeakSourceFileName = "boostunittestsample.cpp";
BoostTestResult testCaseResult = new BoostTestResultBuilder().
For(this.TestCase).
Passed().
Duration(1000).
Log(leak).
Build();
VSTestResult result = testCaseResult.AsVSTestResult(this.TestCase);
AssertVSTestModelProperties(result);
Assert.That(result.Outcome, Is.EqualTo(TestOutcome.Passed));
Assert.That(result.Duration, Is.EqualTo(Microseconds(1000)));
Assert.That(result.Messages.Count, Is.EqualTo(1));
TestResultMessage message = result.Messages.First();
Assert.That(message.Category, Is.EqualTo(TestResultMessage.StandardErrorCategory));
}
public void ConvertFailToVSTestResult()
{
LogEntryError error = new LogEntryError("Error: 1 != 2", new SourceFileInfo("file.cpp", 10));
BoostTestResult testCaseResult = new BoostTestResultBuilder().
For(this.TestCase).
Failed().
Duration(2500).
Log(error).
Build();
VSTestResult result = testCaseResult.AsVSTestResult(this.TestCase);
AssertVSTestModelProperties(result);
Assert.That(result.Outcome, Is.EqualTo(TestOutcome.Failed));
Assert.That(result.Duration, Is.EqualTo(Microseconds(2500)));
AssertVsTestModelError(result, error);
Assert.That(result.Messages.Count, Is.EqualTo(1));
TestResultMessage message = result.Messages.First();
Assert.That(message.Category, Is.EqualTo(TestResultMessage.StandardErrorCategory));
}
public void ConvertExceptionToVSTestResult()
{
LogEntryException exception = new LogEntryException("C string: some error", new SourceFileInfo("unknown location", 0));
exception.LastCheckpoint = new SourceFileInfo("boostunittestsample.cpp", 13);
exception.CheckpointDetail = "Going to throw an exception";
BoostTestResult testCaseResult = new BoostTestResultBuilder().
For(this.TestCase).
Aborted().
Duration(0).
Log(exception).
Build();
VSTestResult result = testCaseResult.AsVSTestResult(this.TestCase);
AssertVSTestModelProperties(result);
Assert.That(result.Outcome, Is.EqualTo(TestOutcome.Failed));
// A 0 duration should list as 1 tick to avoid UI issues in the test adapter
Assert.That(result.Duration, Is.EqualTo(TimeSpan.FromTicks(1)));
AssertVsTestModelError(result, exception);
Assert.That(result.Messages.Count, Is.EqualTo(1));
TestResultMessage message = result.Messages.First();
Assert.That(message.Category, Is.EqualTo(TestResultMessage.StandardErrorCategory));
}
public void DetailedVerbosityShowStdOutMessagesForPassedTests()
{
// Setup
var loggerEvents = new InternalTestLoggerEvents(TestSessionMessageLogger.Instance);
loggerEvents.EnableEvents();
var parameters = new Dictionary <string, string>
{
{ "verbosity", "detailed" }
};
this.consoleLogger.Initialize(loggerEvents, parameters);
var testcase = new TestCase("TestName", new Uri("some://uri"), "TestSource");
string message = "Dummy message";
TestResultMessage testResultMessage = new TestResultMessage(TestResultMessage.StandardOutCategory, message);
var testresult = new ObjectModel.TestResult(testcase)
{
Outcome = TestOutcome.Passed
};
testresult.Messages.Add(testResultMessage);
// Act. Raise an event on mock object
loggerEvents.RaiseTestResult(new TestResultEventArgs(testresult));
loggerEvents.WaitForEventCompletion();
// Verify
this.mockOutput.Verify(o => o.WriteLine(CommandLineResources.StdOutMessagesBanner, OutputLevel.Information), Times.Once());
this.mockOutput.Verify(o => o.WriteLine(" " + message, OutputLevel.Information), Times.Once());
}
private async Task HandleEvent(object sender, BasicDeliverEventArgs args)
{
_logger.LogTrace("Received event on queue");
try
{
using (var scope = _serviceProvider.CreateScope())
{
var dbService = scope.ServiceProvider.GetRequiredService <DbService>();
string message = Encoding.UTF8.GetString(args.Body.ToArray());
TestResultMessage testMessage = JsonSerializer.Deserialize <TestResultMessage>(
message, new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
});
await ProcessResultMessageInsecure(testMessage, dbService);
}
}
catch (Exception e)
{
_logger.LogError("Error during handling received message {message} {e}", args.Body.ToArray(), e);
_logger.LogTrace("Decoded {message}", Encoding.UTF8.GetString(args.Body.ToArray()));
}
finally
{
_channel.BasicAck(args.DeliveryTag, false);
}
}
public void TestResultHandlerShouldNotShowAdditionalInfoBannerIfAdditionalInfoIsEmpty()
{
var loggerEvents = new InternalTestLoggerEvents(TestSessionMessageLogger.Instance);
loggerEvents.EnableEvents();
var parameters = new Dictionary <string, string>
{
{ "verbosity", "normal" }
};
this.consoleLogger.Initialize(loggerEvents, parameters);
var testcase = new TestCase("TestName", new Uri("some://uri"), "TestSource");
TestResultMessage testResultMessage = new TestResultMessage(TestResultMessage.AdditionalInfoCategory, null);
var testresult = new ObjectModel.TestResult(testcase)
{
Outcome = TestOutcome.Failed
};
testresult.Messages.Add(testResultMessage);
loggerEvents.RaiseTestResult(new TestResultEventArgs(testresult));
loggerEvents.WaitForEventCompletion();
this.mockOutput.Verify(o => o.WriteLine(CommandLineResources.AddnlInfoMessagesBanner, OutputLevel.Information), Times.Never());
}
private bool InitializeForTest(ITestElement testElement, IRunContext runContext)
{
var runId = runContext.RunConfig.TestRun.Id;
TestResultMessage failure = null;
try {
var vars = new TestProperties(testElement, runContext.RunConfig.TestRun.RunConfiguration);
InitializeWorker(vars, runContext, testElement).GetAwaiter().GetResult();
_remote.Initialize(_runContext);
AttachDebuggerIfNeeded(runContext, _ide, vars);
} catch (ArgumentException ex) {
failure = GetFailure(ex, runId, testElement);
} catch (TimeoutException ex) {
failure = GetFailure(ex, runId, testElement);
} catch (InvalidOperationException ex) {
failure = GetFailure(ex, runId, testElement);
} catch (Exception ex) {
failure = GetFailure(ex, runId, testElement);
failure.SystemException = ex;
}
if (failure != null)
{
runContext.ResultSink.AddResult(failure);
runContext.StopTestRun();
return(false);
}
return(true);
}
public void TestResultHandlerShouldNotShowDbgTrcMsg()
{
var loggerEvents = new InternalTestLoggerEvents(TestSessionMessageLogger.Instance);
loggerEvents.EnableEvents();
var parameters = new Dictionary <string, string>();
parameters.Add("verbosity", "normal");
this.consoleLogger.Initialize(loggerEvents, parameters);
var testcase = new TestCase("TestName", new Uri("some://uri"), "TestSource");
string message = "Dummy message";
TestResultMessage testResultMessage = new TestResultMessage(TestResultMessage.DebugTraceCategory, message);
var testresult = new ObjectModel.TestResult(testcase)
{
Outcome = TestOutcome.Passed
};
testresult.Messages.Add(testResultMessage);
loggerEvents.RaiseTestResult(new TestResultEventArgs(testresult));
loggerEvents.WaitForEventCompletion();
this.mockOutput.Verify(o => o.WriteLine(CommandLineResources.DbgTrcMessagesBanner, OutputLevel.Information), Times.Never());
this.mockOutput.Verify(o => o.WriteLine(" " + message, OutputLevel.Information), Times.Never());
}
/// <summary>
/// Convert parameter unitTestResult to testResult
/// </summary>
/// <param name="testCase"> The test Case. </param>
/// <param name="startTime"> The start Time. </param>
/// <param name="endTime"> The end Time. </param>
/// <param name="currentSettings">Current MSTest settings.</param>
/// <returns> The <see cref="TestResult"/>. </returns>
internal TestResult ToTestResult(TestCase testCase, DateTimeOffset startTime, DateTimeOffset endTime, MSTestSettings currentSettings)
{
Debug.Assert(testCase != null, "testCase");
var testResult = new TestResult(testCase)
{
DisplayName = this.DisplayName,
Duration = this.Duration,
ErrorMessage = this.ErrorMessage,
ErrorStackTrace = this.ErrorStackTrace,
Outcome = UnitTestOutcomeHelper.ToTestOutcome(this.Outcome, currentSettings),
StartTime = startTime,
EndTime = endTime
};
testResult.SetPropertyValue <Guid>(Constants.ExecutionIdProperty, this.ExecutionId);
testResult.SetPropertyValue <Guid>(Constants.ParentExecIdProperty, this.ParentExecId);
testResult.SetPropertyValue <int>(Constants.InnerResultsCountProperty, this.InnerResultsCount);
if (!string.IsNullOrEmpty(this.StandardOut))
{
TestResultMessage message = new TestResultMessage(TestResultMessage.StandardOutCategory, this.StandardOut);
testResult.Messages.Add(message);
}
if (!string.IsNullOrEmpty(this.StandardError))
{
TestResultMessage message = new TestResultMessage(TestResultMessage.StandardErrorCategory, this.StandardError);
testResult.Messages.Add(message);
}
if (!string.IsNullOrEmpty(this.DebugTrace))
{
string debugTraceMessagesinStdOut = string.Format(CultureInfo.InvariantCulture, "\n\n{0}\n{1}", Resource.DebugTraceBanner, this.DebugTrace);
TestResultMessage debugTraceMessage = new TestResultMessage(TestResultMessage.StandardOutCategory, debugTraceMessagesinStdOut);
testResult.Messages.Add(debugTraceMessage);
}
if (!string.IsNullOrEmpty(this.TestContextMessages))
{
string testContextMessagesInStdOut = string.Format(CultureInfo.InvariantCulture, "\n\n{0}\n{1}", Resource.TestContextMessageBanner, this.TestContextMessages);
TestResultMessage testContextMessage = new TestResultMessage(TestResultMessage.StandardOutCategory, testContextMessagesInStdOut);
testResult.Messages.Add(testContextMessage);
}
if (this.ResultFiles != null && this.ResultFiles.Count > 0)
{
AttachmentSet attachmentSet = new AttachmentSet(Constants.ExecutorUri, Resource.AttachmentSetDisplayName);
foreach (var resultFile in this.ResultFiles)
{
string pathToResultFile = PlatformServiceProvider.Instance.FileOperations.GetFullFilePath(resultFile);
UriDataAttachment attachment = new UriDataAttachment(new Uri(pathToResultFile), resultFile);
attachmentSet.Attachments.Add(attachment);
}
testResult.Attachments.Add(attachmentSet);
}
return(testResult);
}
public void TestResultHandlerShouldShowDbgTrcMsg()
{
var parameters = new Dictionary <string, string>();
parameters.Add("verbosity", "normal");
this.consoleLogger.Initialize(this.events.Object, parameters);
var testcase = new TestCase("TestName", new Uri("some://uri"), "TestSource");
string message = "Dummy message";
TestResultMessage testResultMessage = new TestResultMessage(TestResultMessage.DebugTraceCategory, message);
var testresult = new ObjectModel.TestResult(testcase);
testresult.Outcome = TestOutcome.Passed;
testresult.Messages.Add(testResultMessage);
var eventArgs = new TestRunChangedEventArgs(null, new List <ObjectModel.TestResult> {
testresult
}, null);
// Raise an event on mock object
this.testRunRequest.Raise(m => m.OnRunStatsChange += null, eventArgs);
this.FlushLoggerMessages();
this.mockOutput.Verify(o => o.WriteLine(CommandLineResources.DbgTrcMessagesBanner, OutputLevel.Information), Times.Once());
this.mockOutput.Verify(o => o.WriteLine(" " + message, OutputLevel.Information), Times.Once());
}
public void TestResultHandlerShouldShowStdOutMessagesBannerIfStdOutIsNotEmpty()
{
var count = 0;
this.mockOutput.Setup(o => o.WriteLine(It.IsAny <string>(), It.IsAny <OutputLevel>())).Callback <string, OutputLevel>(
(s, o) => { count++; });
var loggerEvents = new InternalTestLoggerEvents(TestSessionMessageLogger.Instance);
loggerEvents.EnableEvents();
var parameters = new Dictionary <string, string>
{
{ "verbosity", "normal" }
};
this.consoleLogger.Initialize(loggerEvents, parameters);
string message = "Dummy message";
var testcase = new TestCase("TestName", new Uri("some://uri"), "TestSource");
TestResultMessage testResultMessage = new TestResultMessage(TestResultMessage.StandardOutCategory, message);
var testresult = new ObjectModel.TestResult(testcase)
{
Outcome = TestOutcome.Failed
};
testresult.Messages.Add(testResultMessage);
loggerEvents.RaiseTestResult(new TestResultEventArgs(testresult));
// Added this for synchronization
SpinWait.SpinUntil(() => count == 2, 300);
this.mockOutput.Verify(o => o.WriteLine(CommandLineResources.StdOutMessagesBanner, OutputLevel.Information), Times.Once());
this.mockOutput.Verify(o => o.WriteLine(" " + message, OutputLevel.Information), Times.Once());
}
public static Common.Models.TestResultMessage Convert(this TestResultMessage testResult)
{
return(new Common.Models.TestResultMessage()
{
Category = testResult.Category,
Text = testResult.Text
});
}
string GetConsoleOutput (TestResultMessage message)
{
if (message.Messages != null) {
return String.Join (Environment.NewLine, message.Messages);
}
return String.Empty;
}
private void NotifySubscribersOfAddedResult(TestResult result)
{
IMessage message = new TestResultMessage {
TestResult = result
};
NotifySubscribers(observer => observer.OnNext(message));
}
public TestResultMessageDrop MapToDrop(TestResultMessage testResultMessage)
{
return(new TestResultMessageDrop
{
Text = testResultMessage.Text,
Category = testResultMessage.Category
});
}
public void AddFailed(string testName, string errorMessage)
{
var currentOne = FailedTestsResults.LastOrDefault();
if (currentOne == null || currentOne.Name != testName)
{
Failed++;
currentOne = new TestResultMessage();
currentOne.Name = testName;
FailedTestsResults.Add(currentOne);
}
currentOne.ErrorMessages.Add(errorMessage);
}
/// <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);
}
}
public async Task Run_should_notify_subscribers_of_result_on_error()
{
// given
var httpClientMock = new Mock <IHttpClient>();
// Throw an error.
httpClientMock
.Setup(c => c.ExecuteRequestAsync(It.IsAny <IRestRequest>(), new HttpLogWriter()))
.Throws(new InvalidOperationException("Bad"));
TestFileRunner runner = new TestFileRunner(httpClientMock.Object, GetRepositoryFactory(), new JsonConfiguration(), _capturedVariableProviderFactory.Object, GetTestFileRunnerLoggerFactory());
var testFile = CreateTestFile(new[]
{
new Test()
{
Url = "foo1"
},
new Test()
{
Url = "foo2"
},
new Test()
{
Url = "foo3"
}
});
TestResultMessage capturedResult = null;
runner.Subscribe(r =>
{
var item = r as TestResultMessage;
if (item != null)
{
capturedResult = item;
}
});
// when
await runner.RunAsync(testFile, "development", "bob");
// then
Assert.That(capturedResult, Is.Not.Null, "Should have notified of the result.");
Assert.That(capturedResult.TestResult, Is.Not.Null, "Should have test result.");
Assert.That(capturedResult.TestResult.ResultState, Is.EqualTo(TestResultState.Failed), "Should not have succeeded.");
}
/// <summary>
/// Generates a default TestResult for a general executor exception.
/// </summary>
/// <param name="test">The test which failed execution.</param>
/// <returns>A warning TestResult related to the provided test execution exception.</returns>
private static VSTestResult GenerateExecutionExceptionResult(VSTestCase test, Exception ex)
{
VSTestResult result = new VSTestResult(test);
result.ComputerName = Environment.MachineName;
// NOTE Marking test as failed in an attempt to be consistent with the
// 'Boost.Test result file not found' error scenario
result.Outcome = TestOutcome.Failed;
result.ErrorMessage = "Test Execution Error. Refer to 'Output' for more details.";
var message = new TestResultMessage(TestResultMessage.StandardErrorCategory, ex.Message);
result.Messages.Add(message);
return(result);
}
private async Task ProcessResultMessageInsecure(TestResultMessage message, DbService dbService)
{
var testRun = await dbService.Tests.FirstOrDefaultAsync(test => test.Id == message.MetaData);
if (testRun == null)
{
_logger.LogError("Cannot find testRun for results {id} {message}", message.MetaData, message);
return;
}
_logger.LogTrace("Found matching test case");
try
{
using (var client = new WebClient())
{
_logger.LogTrace("Processing students");
var studentData = client.DownloadData(message.Students);
await _storageService.UploadResultAsync(
CreateBlobName(testRun.CreatedBy, testRun.Id, TestRunConstants.FileStudents), studentData);
_logger.LogTrace("Processing teachers");
var teacherData = client.DownloadData(message.Teachers);
await _storageService.UploadResultAsync(
CreateBlobName(testRun.CreatedBy, testRun.Id, TestRunConstants.FileTeachers), teacherData);
_logger.LogTrace("Processing dump");
var zipData = client.DownloadData(message.Data);
await _storageService.UploadResultAsync(
CreateBlobName(testRun.CreatedBy, testRun.Id, TestRunConstants.FileZip), zipData);
}
testRun.Status = TestRunConstants.TestFinished;
testRun.FinishedAt = DateTime.UtcNow;
testRun.Message = TestRunConstants.TestMessageFinished;
await dbService.SaveChangesAsync();
}
catch (Exception e)
{
_logger.LogError("Error during processing result message contents (updating db) {e}", e);
testRun.Status = TestRunConstants.TestFailed;
testRun.Message = TestRunConstants.TestMessageFailed;
testRun.FinishedAt = DateTime.UtcNow;
await dbService.SaveChangesAsync();
throw;
}
}
public void ConvertsDataFromXunitToTdNetFormat()
{
var testCase = Mocks.TestCase<TestResultMessageExtensionsTests>("ConvertsDataFromXunitToTdNetFormat");
var message = new TestResultMessage
{
TestCase = testCase,
TestDisplayName = "Display Name",
ExecutionTime = 123.45M
};
var result = message.ToTdNetTestResult(TestState.Ignored);
Assert.Same(testCase.GetClass(), result.FixtureType);
Assert.Same(testCase.GetMethod(), result.Method);
Assert.Equal("Display Name", result.Name);
Assert.Equal(TimeSpan.FromTicks(1234500), result.TimeSpan);
Assert.Equal(1, result.TotalTests);
}
UnitTestResult AddTestResult (TestResultMessage message)
{
var result = new UnitTestResult {
ConsoleError = message.ErrorMessage,
ConsoleOutput = GetConsoleOutput (message),
Message = message.ErrorMessage,
Status = ToResultStatus (message.Outcome),
StackTrace = message.ErrorStackTrace,
TestDate = message.StartTime.DateTime,
Time = message.Duration,
};
UpdateCounts (result);
TestResult.Add (result);
return result;
}
public IDisposable Subscribe(IObserver <IMessage> observer)
{
// Notify of the observer of existing results.
IEnumerable <TestResult> resultsCopy;
lock (_currentResults)
{
resultsCopy = _currentResults.ToArray();
}
foreach (TestResult testResult in resultsCopy)
{
var message = new TestResultMessage {
TestResult = testResult
};
observer.OnNext(message);
}
return(new TestSessionRunnerSubscriber(observer, _subscribers));
}
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));
}
void OnTestResult (TestResultMessage message)
{
UnitTestResult result = AddTestResult (message);
if (runningSingleTest) {
// Ensure test error message is displayed in Test Results window.
TestResult = result;
return;
}
string testId = message.Test?.Id?.ToString ();
if (currentTest == null || testId != currentTest.TestId) {
currentTest = FindTest (rootTest as UnitTest, testId);
}
if (currentTest != null) {
currentTest.RegisterResult (testContext, result);
testContext.Monitor.EndTest (currentTest, result);
currentTest.Status = TestStatus.Ready;
UpdateParentStatus ();
}
}
public void ConvertPassToVSTestResult()
{
BoostTestResult testCaseResult = new BoostTestResultBuilder().
For(this.TestCase).
Passed().
Duration(1000).
Log(new LogEntryMessage("BOOST_MESSAGE output")).
Build();
VSTestResult result = testCaseResult.AsVSTestResult(this.TestCase);
AssertVSTestModelProperties(result);
Assert.That(result.Outcome, Is.EqualTo(TestOutcome.Passed));
Assert.That(result.Duration, Is.EqualTo(Microseconds(1000)));
Assert.That(result.Messages.Count, Is.EqualTo(1));
TestResultMessage message = result.Messages.First();
Assert.That(message.Category, Is.EqualTo(TestResultMessage.StandardOutCategory));
}
/// <summary>
/// Helper method to send information about the test results to the server
/// e.g. did the test pass/fail/etc?
/// (this is called when a test completes)
/// </summary>
/// <param name="testName">name of test</param>
/// <param name="fixtureName">name of fixture (assembly)</param>
/// <param name="result">test result (<see cref="RevitTestExecutive.RunTest"/></param>
/// <param name="stackTrace">stack trace of failure, if any</param>
public static void SendTestResultInformation(string testName, string fixtureName, string result, string stackTrace)
{
TestResultMessage msg = new TestResultMessage(testName, fixtureName, result, stackTrace);
SendMessage(msg);
}
public TestResult MergeResults(TestResult inMemory, TestResultMessage fromTheWire)
{
return target.MergeResults(inMemory, fromTheWire);
}
/// <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);
}
}
public TestResultMessageDrop(TestResultMessage testResultMessage)
{
_testResultMessage = testResultMessage;
}
public static void SetOutput(this TestResultMessage message, string output)
{
var prop = typeof(TestResultMessage).GetProperty("Output", BindingFlags.Instance | BindingFlags.SetProperty | BindingFlags.NonPublic | BindingFlags.Public);
prop.SetValue(message, output);
}
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);
}
public TestResult MergeResults(TestResult inMemory, TestResultMessage fromTheWire)
{
return(target.MergeResults(inMemory, fromTheWire));
}
