Merge remote-tracking branch 'upstream/master' into fix-italics

* upstream/master:
  Fix another inverted logic error
  Fix test results logic
  Added asnychronous test completed events

Author: 333fred

src/OmniSharp.DotNetTest/TestManager.cs

@@ -200,6 +200,11 @@ private static int FindFreePort()
             }
         }
 
+        protected void EmitTestComletedEvent(DotNetTestResult result)
+        {
+            EventEmitter.Emit("TestCompleted", result);
+        }
+
         protected void EmitTestMessage(TestMessageLevel messageLevel, string message)
         {
             EventEmitter.Emit(TestMessageEvent.Id,

src/OmniSharp.DotNetTest/VSTestManager.cs

@@ -374,7 +374,8 @@ public override async Task<RunTestResponse> RunTestAsync(string[] methodNames, s
 
             var testCases = await DiscoverTestsAsync(methodNames, runSettings, targetFrameworkVersion, cancellationToken);
 
-            var testResults = new List<TestResult>();
+            var passed = true;
+            var results = new List<DotNetTestResult>();
 
             if (testCases.Length > 0)
             {
@@ -400,43 +401,57 @@ public override async Task<RunTestResponse> RunTestAsync(string[] methodNames, s
 
                         case MessageType.TestRunStatsChange:
                             var testRunChange = message.DeserializePayload<TestRunChangedEventArgs>();
-                            testResults.AddRange(testRunChange.NewTestResults);
+                            var newResults = ConvertResults(testRunChange.NewTestResults);
+                            passed = passed && !testRunChange.NewTestResults.Any(o => o.Outcome == TestOutcome.Failed);
+                            results.AddRange(newResults);
+                            foreach (var result in newResults)
+                            {
+                                EmitTestComletedEvent(result);
+                            }
                             break;
 
                         case MessageType.ExecutionComplete:
                             var payload = message.DeserializePayload<TestRunCompletePayload>();
                             if (payload.LastRunTests != null && payload.LastRunTests.NewTestResults != null)
                             {
-                                testResults.AddRange(payload.LastRunTests.NewTestResults);
+                                var lastRunResults = ConvertResults(payload.LastRunTests.NewTestResults);
+                                passed = passed && !payload.LastRunTests.NewTestResults.Any(o => o.Outcome == TestOutcome.Failed);
+                                results.AddRange(lastRunResults);
+                                foreach (var result in lastRunResults)
+                                {
+                                    EmitTestComletedEvent(result);
+                                }
                             }
                             done = true;
                             break;
                     }
                 }
             }
 
-            var results = testResults.Select(testResult =>
-                new DotNetTestResult
-                {
-                    MethodName = testResult.TestCase.FullyQualifiedName,
-                    Outcome = testResult.Outcome.ToString().ToLowerInvariant(),
-                    ErrorMessage = testResult.ErrorMessage,
-                    ErrorStackTrace = testResult.ErrorStackTrace,
-                    StandardOutput = testResult.Messages
-                        .Where(message => message.Category == TestResultMessage.StandardOutCategory)
-                        .Select(message => message.Text).ToArray(),
-                    StandardError = testResult.Messages.Where(message => message.Category == TestResultMessage.StandardErrorCategory)
-                        .Select(message => message.Text).ToArray()
-                });
-
             return new RunTestResponse
             {
                 Results = results.ToArray(),
-                Pass = !testResults.Any(r => r.Outcome == TestOutcome.Failed),
+                Pass = passed,
                 ContextHadNoTests = false
             };
         }
 
+        private static IEnumerable<DotNetTestResult> ConvertResults(IEnumerable<TestResult> results)
+        {
+            return results.Select(testResult => new DotNetTestResult
+            {
+                MethodName = testResult.TestCase.FullyQualifiedName,
+                Outcome = testResult.Outcome.ToString().ToLowerInvariant(),
+                ErrorMessage = testResult.ErrorMessage,
+                ErrorStackTrace = testResult.ErrorStackTrace,
+                StandardOutput = testResult.Messages
+                    .Where(message => message.Category == TestResultMessage.StandardOutCategory)
+                    .Select(message => message.Text).ToArray(),
+                StandardError = testResult.Messages.Where(message => message.Category == TestResultMessage.StandardErrorCategory)
+                    .Select(message => message.Text).ToArray()
+            });
+        }
+
         private async Task<TestCase[]> DiscoverTestsAsync(string[] methodNames, string runSettings, string targetFrameworkVersion, CancellationToken cancellationToken)
         {
             SendMessage(MessageType.StartDiscovery,