From b2e485803c28af1771ba9de2e0d892f118a5b894 Mon Sep 17 00:00:00 2001 From: nohwnd Date: Fri, 16 Apr 2021 16:27:35 +0200 Subject: [PATCH 1/3] Abort when init and run messages fail to process, usually on deserialization, to prevent the host from hanging --- .../Utilities/AssemblyResolver.cs | 10 +- .../EventHandlers/TestRequestHandler.cs | 224 ++++++++++++------ 2 files changed, 156 insertions(+), 78 deletions(-) diff --git a/src/Microsoft.TestPlatform.Common/Utilities/AssemblyResolver.cs b/src/Microsoft.TestPlatform.Common/Utilities/AssemblyResolver.cs index 603312785b..c830d88dff 100644 --- a/src/Microsoft.TestPlatform.Common/Utilities/AssemblyResolver.cs +++ b/src/Microsoft.TestPlatform.Common/Utilities/AssemblyResolver.cs @@ -106,6 +106,7 @@ private Assembly OnResolve(object sender, AssemblyResolveEventArgs args) if (this.searchDirectories == null || this.searchDirectories.Count == 0) { + EqtTrace.Info("AssemblyResolver.OnResolve: {0}: There are no search directories, returning.", args.Name); return null; } @@ -146,6 +147,8 @@ private Assembly OnResolve(object sender, AssemblyResolveEventArgs args) continue; } + EqtTrace.Info("AssemblyResolver.OnResolve: {0}: Searching in: '{1}'.", args.Name, dir); + foreach (var extension in SupportedFileExtensions) { var assemblyPath = Path.Combine(dir, requestedName.Name + extension); @@ -153,6 +156,8 @@ private Assembly OnResolve(object sender, AssemblyResolveEventArgs args) { if (!File.Exists(assemblyPath)) { + EqtTrace.Info("AssemblyResolver.OnResolve: {0}: Assembly path does not exist: '{1}', returning.", args.Name, assemblyPath); + continue; } @@ -160,9 +165,12 @@ private Assembly OnResolve(object sender, AssemblyResolveEventArgs args) if (!this.RequestedAssemblyNameMatchesFound(requestedName, foundName)) { + EqtTrace.Info("AssemblyResolver.OnResolve: {0}: File exists but version/public key is wrong. Try next extension.", args.Name); continue; // File exists but version/public key is wrong. Try next extension. } + EqtTrace.Info("AssemblyResolver.OnResolve: {0}: Loading assembly '{1}'.", args.Name, assemblyPath); + assembly = this.platformAssemblyLoadContext.LoadAssemblyFromPath(assemblyPath); this.resolvedAssemblies[args.Name] = assembly; @@ -172,7 +180,7 @@ private Assembly OnResolve(object sender, AssemblyResolveEventArgs args) } catch (FileLoadException ex) { - EqtTrace.Info("AssemblyResolver.OnResolve: {0}: Failed to load assembly. Reason:{1} ", args.Name, ex); + EqtTrace.Error("AssemblyResolver.OnResolve: {0}: Failed to load assembly. Reason:{1} ", args.Name, ex); // Re-throw FileLoadException, because this exception means that the assembly // was found, but could not be loaded. This will allow us to report a more diff --git a/src/Microsoft.TestPlatform.CrossPlatEngine/EventHandlers/TestRequestHandler.cs b/src/Microsoft.TestPlatform.CrossPlatEngine/EventHandlers/TestRequestHandler.cs index 50137fe787..43c3a19ecd 100644 --- a/src/Microsoft.TestPlatform.CrossPlatEngine/EventHandlers/TestRequestHandler.cs +++ b/src/Microsoft.TestPlatform.CrossPlatEngine/EventHandlers/TestRequestHandler.cs @@ -42,7 +42,7 @@ public class TestRequestHandler : ITestRequestHandler private Action onLaunchAdapterProcessWithDebuggerAttachedAckReceived; private Action onAttachDebuggerAckRecieved; - public TestHostConnectionInfo ConnectionInfo { get; set; } + public TestHostConnectionInfo ConnectionInfo { get; set; } /// /// Initializes a new instance of the . @@ -263,98 +263,142 @@ public void OnMessageReceived(object sender, MessageReceivedEventArgs messageRec switch (message.MessageType) { case MessageType.VersionCheck: - var version = this.dataSerializer.DeserializePayload(message); - // choose the highest version that we both support - var negotiatedVersion = Math.Min(version, highestSupportedVersion); - // BUT don't choose 3, because protocol version 3 has performance problems in 16.7.1-16.8. Those problems are caused - // by choosing payloadSerializer instead of payloadSerializer2 for protocol version 3. - // - // We cannot just update the code to choose the new serializer, because then that change would apply only to testhost. - // Testhost is is delivered by Microsoft.NET.Test.SDK nuget package, and can be used with an older vstest.console. - // An older vstest.console, that supports protocol version 3, would serialize its messages using payloadSerializer, - // but the fixed testhost would serialize it using payloadSerializer2, resulting in incompatible messages. - // - // Instead we must downgrade to protocol version 2 when 3 would be negotiated. Or higher when higher version - // would be negotiated. - if (negotiatedVersion != 3) + try { - this.protocolVersion = negotiatedVersion; - } - else - { - var flag = Environment.GetEnvironmentVariable("VSTEST_DISABLE_PROTOCOL_3_VERSION_DOWNGRADE"); - var flagIsEnabled = flag != null && flag != "0"; - var dowgradeIsDisabled = flagIsEnabled; - if (dowgradeIsDisabled) + var version = this.dataSerializer.DeserializePayload(message); + // choose the highest version that we both support + var negotiatedVersion = Math.Min(version, highestSupportedVersion); + // BUT don't choose 3, because protocol version 3 has performance problems in 16.7.1-16.8. Those problems are caused + // by choosing payloadSerializer instead of payloadSerializer2 for protocol version 3. + // + // We cannot just update the code to choose the new serializer, because then that change would apply only to testhost. + // Testhost is is delivered by Microsoft.NET.Test.SDK nuget package, and can be used with an older vstest.console. + // An older vstest.console, that supports protocol version 3, would serialize its messages using payloadSerializer, + // but the fixed testhost would serialize it using payloadSerializer2, resulting in incompatible messages. + // + // Instead we must downgrade to protocol version 2 when 3 would be negotiated. Or higher when higher version + // would be negotiated. + if (negotiatedVersion != 3) { this.protocolVersion = negotiatedVersion; } else { - this.protocolVersion = 2; + var flag = Environment.GetEnvironmentVariable("VSTEST_DISABLE_PROTOCOL_3_VERSION_DOWNGRADE"); + var flagIsEnabled = flag != null && flag != "0"; + var dowgradeIsDisabled = flagIsEnabled; + if (dowgradeIsDisabled) + { + this.protocolVersion = negotiatedVersion; + } + else + { + this.protocolVersion = 2; + } } - } - // Send the negotiated protocol to request sender - this.channel.Send(this.dataSerializer.SerializePayload(MessageType.VersionCheck, this.protocolVersion)); + // Send the negotiated protocol to request sender + this.channel.Send(this.dataSerializer.SerializePayload(MessageType.VersionCheck, this.protocolVersion)); - // Can only do this after InitializeCommunication because TestHost cannot "Send Log" unless communications are initialized - if (!string.IsNullOrEmpty(EqtTrace.LogFile)) - { - this.SendLog(TestMessageLevel.Informational, string.Format(CrossPlatResources.TesthostDiagLogOutputFile, EqtTrace.LogFile)); + // Can only do this after InitializeCommunication because TestHost cannot "Send Log" unless communications are initialized + if (!string.IsNullOrEmpty(EqtTrace.LogFile)) + { + this.SendLog(TestMessageLevel.Informational, string.Format(CrossPlatResources.TesthostDiagLogOutputFile, EqtTrace.LogFile)); + } + else if (!string.IsNullOrEmpty(EqtTrace.ErrorOnInitialization)) + { + this.SendLog(TestMessageLevel.Warning, EqtTrace.ErrorOnInitialization); + } } - else if (!string.IsNullOrEmpty(EqtTrace.ErrorOnInitialization)) + catch (Exception ex) { - this.SendLog(TestMessageLevel.Warning, EqtTrace.ErrorOnInitialization); + EqtTrace.Error("Failed processing message {0}, aborting test run.", message.MessageType); + EqtTrace.Error(ex); + goto case MessageType.AbortTestRun; } break; case MessageType.DiscoveryInitialize: { - EqtTrace.Info("Discovery Session Initialize."); - this.testHostManagerFactoryReady.Wait(); - var discoveryEventsHandler = new TestDiscoveryEventHandler(this); - var pathToAdditionalExtensions = this.dataSerializer.DeserializePayload>(message); - jobQueue.QueueJob( - () => - testHostManagerFactory.GetDiscoveryManager().Initialize(pathToAdditionalExtensions, discoveryEventsHandler), 0); + try + { + this.testHostManagerFactoryReady.Wait(); + var discoveryEventsHandler = new TestDiscoveryEventHandler(this); + var pathToAdditionalExtensions = this.dataSerializer.DeserializePayload>(message); + Action job = () => + { + EqtTrace.Info("TestRequestHandler.OnMessageReceived: Running job '{0}'.", message.MessageType); + testHostManagerFactory.GetDiscoveryManager().Initialize(pathToAdditionalExtensions, discoveryEventsHandler); + }; + jobQueue.QueueJob(job, 0); + } + catch (Exception ex) + { + EqtTrace.Error("Failed processing message {0}, aborting test run.", message.MessageType); + EqtTrace.Error(ex); + goto case MessageType.AbortTestRun; + } break; } case MessageType.StartDiscovery: { - EqtTrace.Info("Discovery started."); - this.testHostManagerFactoryReady.Wait(); - var discoveryEventsHandler = new TestDiscoveryEventHandler(this); - var discoveryCriteria = this.dataSerializer.DeserializePayload(message); - jobQueue.QueueJob( - () => + try + { + this.testHostManagerFactoryReady.Wait(); + var discoveryEventsHandler = new TestDiscoveryEventHandler(this); + var discoveryCriteria = this.dataSerializer.DeserializePayload(message); + Action job = () => + { + EqtTrace.Info("TestRequestHandler.OnMessageReceived: Running job '{0}'.", message.MessageType); testHostManagerFactory.GetDiscoveryManager() - .DiscoverTests(discoveryCriteria, discoveryEventsHandler), 0); + .DiscoverTests(discoveryCriteria, discoveryEventsHandler); + }; + jobQueue.QueueJob(job, 0); + } + catch (Exception ex) + { + EqtTrace.Error("Failed processing message {0}, aborting test run.", message.MessageType); + EqtTrace.Error(ex); + goto case MessageType.AbortTestRun; + } break; } case MessageType.ExecutionInitialize: { - EqtTrace.Info("Execution Session Initialize."); - this.testHostManagerFactoryReady.Wait(); - var testInitializeEventsHandler = new TestInitializeEventsHandler(this); - var pathToAdditionalExtensions = this.dataSerializer.DeserializePayload>(message); - jobQueue.QueueJob( - () => - testHostManagerFactory.GetExecutionManager().Initialize(pathToAdditionalExtensions, testInitializeEventsHandler), 0); + try + { + this.testHostManagerFactoryReady.Wait(); + var testInitializeEventsHandler = new TestInitializeEventsHandler(this); + var pathToAdditionalExtensions = this.dataSerializer.DeserializePayload>(message); + Action job = () => + { + EqtTrace.Info("TestRequestHandler.OnMessageReceived: Running job '{0}'.", message.MessageType); + testHostManagerFactory.GetExecutionManager().Initialize(pathToAdditionalExtensions, testInitializeEventsHandler); + }; + jobQueue.QueueJob(job, 0); + } + catch (Exception ex) + { + EqtTrace.Error("Failed processing message {0}, aborting test run.", message.MessageType); + EqtTrace.Error(ex); + goto case MessageType.AbortTestRun; + } break; } case MessageType.StartTestExecutionWithSources: { - EqtTrace.Info("Execution started."); - var testRunEventsHandler = new TestRunEventsHandler(this); - this.testHostManagerFactoryReady.Wait(); - var testRunCriteriaWithSources = this.dataSerializer.DeserializePayload(message); - jobQueue.QueueJob( - () => + try + { + var testRunEventsHandler = new TestRunEventsHandler(this); + this.testHostManagerFactoryReady.Wait(); + var testRunCriteriaWithSources = this.dataSerializer.DeserializePayload(message); + Action job = () => + { + EqtTrace.Info("TestRequestHandler.OnMessageReceived: Running job '{0}'.", message.MessageType); testHostManagerFactory.GetExecutionManager() .StartTestRun( testRunCriteriaWithSources.AdapterSourceMap, @@ -362,22 +406,31 @@ public void OnMessageReceived(object sender, MessageReceivedEventArgs messageRec testRunCriteriaWithSources.RunSettings, testRunCriteriaWithSources.TestExecutionContext, this.GetTestCaseEventsHandler(testRunCriteriaWithSources.RunSettings), - testRunEventsHandler), - 0); - + testRunEventsHandler); + }; + jobQueue.QueueJob(job, 0); + } + catch (Exception ex) + { + EqtTrace.Error("Failed processing message {0}, aborting test run.", message.MessageType); + EqtTrace.Error(ex); + goto case MessageType.AbortTestRun; + } break; } case MessageType.StartTestExecutionWithTests: { - EqtTrace.Info("Execution started."); - var testRunEventsHandler = new TestRunEventsHandler(this); - this.testHostManagerFactoryReady.Wait(); - var testRunCriteriaWithTests = - this.dataSerializer.DeserializePayload(message); - - jobQueue.QueueJob( - () => + try + { + var testRunEventsHandler = new TestRunEventsHandler(this); + this.testHostManagerFactoryReady.Wait(); + var testRunCriteriaWithTests = + this.dataSerializer.DeserializePayload(message); + + Action job = () => + { + EqtTrace.Info("TestRequestHandler.OnMessageReceived: Running job '{0}'.", message.MessageType); testHostManagerFactory.GetExecutionManager() .StartTestRun( testRunCriteriaWithTests.Tests, @@ -385,9 +438,16 @@ public void OnMessageReceived(object sender, MessageReceivedEventArgs messageRec testRunCriteriaWithTests.RunSettings, testRunCriteriaWithTests.TestExecutionContext, this.GetTestCaseEventsHandler(testRunCriteriaWithTests.RunSettings), - testRunEventsHandler), - 0); - + testRunEventsHandler); + }; + jobQueue.QueueJob(job, 0); + } + catch (Exception ex) + { + EqtTrace.Error("Failed processing message {0}, aborting test run.", message.MessageType); + EqtTrace.Error(ex); + goto case MessageType.AbortTestRun; + } break; } @@ -406,9 +466,19 @@ public void OnMessageReceived(object sender, MessageReceivedEventArgs messageRec break; case MessageType.AbortTestRun: - jobQueue.Pause(); - this.testHostManagerFactoryReady.Wait(); - testHostManagerFactory.GetExecutionManager().Abort(new TestRunEventsHandler(this)); + try + { + jobQueue.Pause(); + this.testHostManagerFactoryReady.Wait(); + testHostManagerFactory.GetExecutionManager().Abort(new TestRunEventsHandler(this)); + } + catch (Exception ex) + { + EqtTrace.Error("Failed processing message {0}. Stopping communication.", message.MessageType); + EqtTrace.Error(ex); + sessionCompleted.Set(); + this.Close(); + } break; case MessageType.SessionEnd: From a2b876c3c2e8a5d27971169da9adb241199e7ab3 Mon Sep 17 00:00:00 2001 From: nohwnd Date: Fri, 16 Apr 2021 17:57:59 +0200 Subject: [PATCH 2/3] Send the message via the abort handler when we abort the run --- .../ExtensionFramework/TestPluginCache.cs | 2 +- .../EventHandlers/TestRequestHandler.cs | 25 ++++++++++++++++++- src/vstest.console/Internal/ConsoleLogger.cs | 20 ++++++++++++--- .../Resources/Resources.Designer.cs | 9 +++++++ src/vstest.console/Resources/Resources.resx | 3 +++ 5 files changed, 54 insertions(+), 5 deletions(-) diff --git a/src/Microsoft.TestPlatform.Common/ExtensionFramework/TestPluginCache.cs b/src/Microsoft.TestPlatform.Common/ExtensionFramework/TestPluginCache.cs index 605c1fa8fe..5344b257ad 100644 --- a/src/Microsoft.TestPlatform.Common/ExtensionFramework/TestPluginCache.cs +++ b/src/Microsoft.TestPlatform.Common/ExtensionFramework/TestPluginCache.cs @@ -529,7 +529,7 @@ private Assembly CurrentDomainAssemblyResolve(object sender, AssemblyResolveEven { try { - EqtTrace.Verbose("CurrentDomain_AssemblyResolve: Resolving assembly '{0}'.", args.Name); + EqtTrace.Verbose("CurrentDomainAssemblyResolve: Resolving assembly '{0}'.", args.Name); if (this.resolvedAssemblies.TryGetValue(args.Name, out assembly)) { diff --git a/src/Microsoft.TestPlatform.CrossPlatEngine/EventHandlers/TestRequestHandler.cs b/src/Microsoft.TestPlatform.CrossPlatEngine/EventHandlers/TestRequestHandler.cs index 43c3a19ecd..5157d5bef7 100644 --- a/src/Microsoft.TestPlatform.CrossPlatEngine/EventHandlers/TestRequestHandler.cs +++ b/src/Microsoft.TestPlatform.CrossPlatEngine/EventHandlers/TestRequestHandler.cs @@ -41,6 +41,7 @@ public class TestRequestHandler : ITestRequestHandler private ManualResetEventSlim sessionCompleted; private Action onLaunchAdapterProcessWithDebuggerAttachedAckReceived; private Action onAttachDebuggerAckRecieved; + private Exception messageProcessingUnrecoverableError; public TestHostConnectionInfo ConnectionInfo { get; set; } @@ -167,6 +168,17 @@ public void SendExecutionComplete( ICollection runContextAttachments, ICollection executorUris) { + if (testRunCompleteArgs.IsAborted && testRunCompleteArgs.Error == null && this.messageProcessingUnrecoverableError != null) + { + var curentArgs = testRunCompleteArgs; + testRunCompleteArgs = new TestRunCompleteEventArgs( + curentArgs.TestRunStatistics, + curentArgs.IsCanceled, + curentArgs.IsAborted, + this.messageProcessingUnrecoverableError, + curentArgs.AttachmentSets, curentArgs.ElapsedTimeInRunningTests + ); + } var data = this.dataSerializer.SerializePayload( MessageType.ExecutionComplete, new TestRunCompletePayload @@ -257,7 +269,7 @@ public void OnMessageReceived(object sender, MessageReceivedEventArgs messageRec if (EqtTrace.IsInfoEnabled) { - EqtTrace.Info("TestRequestHandler.ProcessRequests: received message: {0}", message); + EqtTrace.Info("TestRequestHandler.OnMessageReceived: received message: {0}", message); } switch (message.MessageType) @@ -312,6 +324,7 @@ public void OnMessageReceived(object sender, MessageReceivedEventArgs messageRec } catch (Exception ex) { + this.messageProcessingUnrecoverableError = ex; EqtTrace.Error("Failed processing message {0}, aborting test run.", message.MessageType); EqtTrace.Error(ex); goto case MessageType.AbortTestRun; @@ -334,6 +347,7 @@ public void OnMessageReceived(object sender, MessageReceivedEventArgs messageRec } catch (Exception ex) { + this.messageProcessingUnrecoverableError = ex; EqtTrace.Error("Failed processing message {0}, aborting test run.", message.MessageType); EqtTrace.Error(ex); goto case MessageType.AbortTestRun; @@ -359,6 +373,7 @@ public void OnMessageReceived(object sender, MessageReceivedEventArgs messageRec } catch (Exception ex) { + this.messageProcessingUnrecoverableError = ex; EqtTrace.Error("Failed processing message {0}, aborting test run.", message.MessageType); EqtTrace.Error(ex); goto case MessageType.AbortTestRun; @@ -373,6 +388,11 @@ public void OnMessageReceived(object sender, MessageReceivedEventArgs messageRec this.testHostManagerFactoryReady.Wait(); var testInitializeEventsHandler = new TestInitializeEventsHandler(this); var pathToAdditionalExtensions = this.dataSerializer.DeserializePayload>(message); + var a = true; + if (a) + { + throw new InvalidOperationException("fffffaaaail!"); + } Action job = () => { EqtTrace.Info("TestRequestHandler.OnMessageReceived: Running job '{0}'.", message.MessageType); @@ -382,6 +402,7 @@ public void OnMessageReceived(object sender, MessageReceivedEventArgs messageRec } catch (Exception ex) { + this.messageProcessingUnrecoverableError = ex; EqtTrace.Error("Failed processing message {0}, aborting test run.", message.MessageType); EqtTrace.Error(ex); goto case MessageType.AbortTestRun; @@ -412,6 +433,7 @@ public void OnMessageReceived(object sender, MessageReceivedEventArgs messageRec } catch (Exception ex) { + this.messageProcessingUnrecoverableError = ex; EqtTrace.Error("Failed processing message {0}, aborting test run.", message.MessageType); EqtTrace.Error(ex); goto case MessageType.AbortTestRun; @@ -444,6 +466,7 @@ public void OnMessageReceived(object sender, MessageReceivedEventArgs messageRec } catch (Exception ex) { + this.messageProcessingUnrecoverableError = ex; EqtTrace.Error("Failed processing message {0}, aborting test run.", message.MessageType); EqtTrace.Error(ex); goto case MessageType.AbortTestRun; diff --git a/src/vstest.console/Internal/ConsoleLogger.cs b/src/vstest.console/Internal/ConsoleLogger.cs index 774bcd707a..e4afd7de3c 100644 --- a/src/vstest.console/Internal/ConsoleLogger.cs +++ b/src/vstest.console/Internal/ConsoleLogger.cs @@ -788,7 +788,7 @@ private void TestRunCompleteHandler(object sender, TestRunCompleteEventArgs e) sourceName, frameworkString); - + ConsoleColor? color = null; if (sourceOutcome == TestOutcome.Failed) { @@ -831,7 +831,14 @@ private void TestRunCompleteHandler(object sender, TestRunCompleteEventArgs e) } else if (e.IsAborted) { - Output.Error(false, CommandLineResources.TestRunAborted); + if (e.Error == null) + { + Output.Error(false, CommandLineResources.TestRunAborted); + } + else + { + Output.Error(false, CommandLineResources.TestRunAbortedWithError, e.Error); + } } return; @@ -843,7 +850,14 @@ private void TestRunCompleteHandler(object sender, TestRunCompleteEventArgs e) } else if (e.IsAborted) { - Output.Error(false, CommandLineResources.TestRunAborted); + if (e.Error == null) + { + Output.Error(false, CommandLineResources.TestRunAborted); + } + else + { + Output.Error(false, CommandLineResources.TestRunAbortedWithError, e.Error); + } } else if (failedTests > 0 || this.testRunHasErrorMessages) { diff --git a/src/vstest.console/Resources/Resources.Designer.cs b/src/vstest.console/Resources/Resources.Designer.cs index 840adf11b8..79687d5fca 100644 --- a/src/vstest.console/Resources/Resources.Designer.cs +++ b/src/vstest.console/Resources/Resources.Designer.cs @@ -1574,6 +1574,15 @@ internal static string TestRunAborted { } } + /// + /// Looks up a localized string similar to Test Run Aborted with error: {0}.. + /// + internal static string TestRunAbortedWithError { + get { + return ResourceManager.GetString("TestRunAbortedWithError", resourceCulture); + } + } + /// /// Looks up a localized string similar to Test Run Canceled.. /// diff --git a/src/vstest.console/Resources/Resources.resx b/src/vstest.console/Resources/Resources.resx index 2c0bb837a1..fdb826947a 100644 --- a/src/vstest.console/Resources/Resources.resx +++ b/src/vstest.console/Resources/Resources.resx @@ -763,4 +763,7 @@ Environment variable '{0}' was already defined, but it's overridden by -Environment argument. + + Test Run Aborted with error {0}. + \ No newline at end of file From 65e4de714fefa6193ce0754c98214edadf127ee4 Mon Sep 17 00:00:00 2001 From: nohwnd Date: Fri, 16 Apr 2021 18:01:42 +0200 Subject: [PATCH 3/3] Remove failure --- .../EventHandlers/TestRequestHandler.cs | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/src/Microsoft.TestPlatform.CrossPlatEngine/EventHandlers/TestRequestHandler.cs b/src/Microsoft.TestPlatform.CrossPlatEngine/EventHandlers/TestRequestHandler.cs index 5157d5bef7..bbfe0ee0ca 100644 --- a/src/Microsoft.TestPlatform.CrossPlatEngine/EventHandlers/TestRequestHandler.cs +++ b/src/Microsoft.TestPlatform.CrossPlatEngine/EventHandlers/TestRequestHandler.cs @@ -168,6 +168,8 @@ public void SendExecutionComplete( ICollection runContextAttachments, ICollection executorUris) { + // When we abort the run we might have saved the error before we gave the handler the chance to abort + // if the handler does not return with any new error we report the original one. if (testRunCompleteArgs.IsAborted && testRunCompleteArgs.Error == null && this.messageProcessingUnrecoverableError != null) { var curentArgs = testRunCompleteArgs; @@ -388,11 +390,6 @@ public void OnMessageReceived(object sender, MessageReceivedEventArgs messageRec this.testHostManagerFactoryReady.Wait(); var testInitializeEventsHandler = new TestInitializeEventsHandler(this); var pathToAdditionalExtensions = this.dataSerializer.DeserializePayload>(message); - var a = true; - if (a) - { - throw new InvalidOperationException("fffffaaaail!"); - } Action job = () => { EqtTrace.Info("TestRequestHandler.OnMessageReceived: Running job '{0}'.", message.MessageType);