Show running tests

src/Platform/Microsoft.Testing.Platform/OutputDevice/Terminal/AnsiTerminal.cs

@@ -45,7 +45,7 @@ internal sealed class AnsiTerminal : ITerminal
     private readonly bool _useBusyIndicator;
     private readonly StringBuilder _stringBuilder = new();
     private bool _isBatching;
-    private AnsiTerminalTestProgressFrame _currentFrame = new(Array.Empty<TestProgressState>(), 0, 0);
+    private AnsiTerminalTestProgressFrame _currentFrame = new(0, 0);
 
     public AnsiTerminal(IConsole console, string? baseDirectory)
     {
@@ -274,27 +274,20 @@ public void SetCursorHorizontal(int position)
     /// </summary>
     public void EraseProgress()
     {
-        if (_currentFrame.ProgressCount == 0)
+        if (_currentFrame.RenderedLines == null || _currentFrame.RenderedLines.Count == 0)
         {
             return;
         }
 
-        AppendLine($"{AnsiCodes.CSI}{_currentFrame.ProgressCount + 2}{AnsiCodes.MoveUpToLineStart}");
+        AppendLine($"{AnsiCodes.CSI}{_currentFrame.RenderedLines.Count + 2}{AnsiCodes.MoveUpToLineStart}");
         Append($"{AnsiCodes.CSI}{AnsiCodes.EraseInDisplay}");
         _currentFrame.Clear();
     }
 
     public void RenderProgress(TestProgressState?[] progress)
     {
-        AnsiTerminalTestProgressFrame newFrame = new(progress, Width, Height);
-
-        // Do not render delta but clear everything if Terminal width or height have changed.
-        if (newFrame.Width != _currentFrame.Width || newFrame.Height != _currentFrame.Height)
-        {
-            EraseProgress();
-        }
-
-        newFrame.Render(_currentFrame, this);
+        AnsiTerminalTestProgressFrame newFrame = new(Width, Height);
+        newFrame.Render(_currentFrame, progress, terminal: this);
 
         _currentFrame = newFrame;
     }

src/Platform/Microsoft.Testing.Platform/OutputDevice/Terminal/HumanReadableDurationFormatter.cs

@@ -55,8 +55,13 @@ public static void Append(ITerminal terminal, TimeSpan duration, bool wrapInPare
     private static string GetFormattedPart(int value, bool hasParentValue, string suffix, int paddingWitdh = 2)
         => $"{(hasParentValue ? " " : string.Empty)}{(hasParentValue ? value.ToString(CultureInfo.InvariantCulture).PadLeft(paddingWitdh, '0') : value.ToString(CultureInfo.InvariantCulture))}{suffix}";
 
-    public static string Render(TimeSpan duration, bool wrapInParentheses = true, bool showMilliseconds = false)
+    public static string Render(TimeSpan? duration, bool wrapInParentheses = true, bool showMilliseconds = false)
     {
+        if (duration is null)
+        {
+            return string.Empty;
+        }
+
         bool hasParentValue = false;
 
         var stringBuilder = new StringBuilder();
@@ -66,35 +71,35 @@ public static string Render(TimeSpan duration, bool wrapInParentheses = true, bo
             stringBuilder.Append('(');
         }
 
-        if (duration.Days > 0)
+        if (duration.Value.Days > 0)
         {
-            stringBuilder.Append(CultureInfo.CurrentCulture, $"{duration.Days}d");
+            stringBuilder.Append(CultureInfo.CurrentCulture, $"{duration.Value.Days}d");
             hasParentValue = true;
         }
 
-        if (duration.Hours > 0 || hasParentValue)
+        if (duration.Value.Hours > 0 || hasParentValue)
         {
-            stringBuilder.Append(GetFormattedPart(duration.Hours, hasParentValue, "h"));
+            stringBuilder.Append(GetFormattedPart(duration.Value.Hours, hasParentValue, "h"));
             hasParentValue = true;
         }
 
-        if (duration.Minutes > 0 || hasParentValue)
+        if (duration.Value.Minutes > 0 || hasParentValue)
         {
-            stringBuilder.Append(GetFormattedPart(duration.Minutes, hasParentValue, "m"));
+            stringBuilder.Append(GetFormattedPart(duration.Value.Minutes, hasParentValue, "m"));
             hasParentValue = true;
         }
 
-        if (duration.Seconds > 0 || hasParentValue || !showMilliseconds)
+        if (duration.Value.Seconds > 0 || hasParentValue || !showMilliseconds)
         {
-            stringBuilder.Append(GetFormattedPart(duration.Seconds, hasParentValue, "s"));
+            stringBuilder.Append(GetFormattedPart(duration.Value.Seconds, hasParentValue, "s"));
             hasParentValue = true;
         }
 
         if (showMilliseconds)
         {
-            if (duration.Milliseconds >= 0 || hasParentValue)
+            if (duration.Value.Milliseconds >= 0 || hasParentValue)
             {
-                stringBuilder.Append(GetFormattedPart(duration.Milliseconds, hasParentValue, "ms", paddingWitdh: 3));
+                stringBuilder.Append(GetFormattedPart(duration.Value.Milliseconds, hasParentValue, "ms", paddingWitdh: 3));
             }
         }
 

src/Platform/Microsoft.Testing.Platform/OutputDevice/Terminal/NonAnsiTerminal.cs

@@ -183,7 +183,8 @@ public void RenderProgress(TestProgressState?[] progress)
 
             // Use just ascii here, so we don't put too many restrictions on fonts needing to
             // properly show unicode, or logs being saved in particular encoding.
-            string? detail = !RoslynString.IsNullOrWhiteSpace(p.Detail) ? $"- {p.Detail}" : null;
+            TestDetailState? activeTest = p.TestNodeResultsState?.GetFirstRunningTask();
+            string? detail = !RoslynString.IsNullOrWhiteSpace(activeTest?.Text) ? $"- {activeTest.Text}" : null;
             Append('[');
             SetColor(TerminalColor.DarkGreen);
             Append('+');

src/Platform/Microsoft.Testing.Platform/OutputDevice/Terminal/TerminalTestReporter.cs

@@ -31,6 +31,18 @@ internal sealed partial class TerminalTestReporter : IDisposable
 
     internal Func<IStopwatch> CreateStopwatch { get; set; } = SystemStopwatch.StartNew;
 
+    internal event EventHandler OnProgressStartUpdate
+    {
+        add => _terminalWithProgress.OnProgressStartUpdate += value;
+        remove => _terminalWithProgress.OnProgressStartUpdate -= value;
+    }
+
+    internal event EventHandler OnProgressStopUpdate
+    {
+        add => _terminalWithProgress.OnProgressStopUpdate += value;
+        remove => _terminalWithProgress.OnProgressStopUpdate -= value;
+    }
+
     private readonly ConcurrentDictionary<string, TestProgressState> _assemblies = new();
 
     private readonly List<TestRunArtifact> _artifacts = new();
@@ -108,10 +120,12 @@ private static Regex GetFrameRegex()
     }
 #endif
 
+    private int _counter;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="TerminalTestReporter"/> class with custom terminal and manual refresh for testing.
     /// </summary>
-    internal TerminalTestReporter(IConsole console, TerminalTestReporterOptions options)
+    public TerminalTestReporter(IConsole console, TerminalTestReporterOptions options)
     {
         _options = options;
 
@@ -168,15 +182,15 @@ private TestProgressState GetOrAddAssemblyRun(string assembly, string? targetFra
         return _assemblies.GetOrAdd(key, _ =>
         {
             IStopwatch sw = CreateStopwatch();
-            var assemblyRun = new TestProgressState(assembly, targetFramework, architecture, sw);
+            var assemblyRun = new TestProgressState(Interlocked.Increment(ref _counter), assembly, targetFramework, architecture, sw);
             int slotIndex = _terminalWithProgress.AddWorker(assemblyRun);
             assemblyRun.SlotIndex = slotIndex;
 
             return assemblyRun;
         });
     }
 
-    internal void TestExecutionCompleted(DateTimeOffset endTime)
+    public void TestExecutionCompleted(DateTimeOffset endTime)
     {
         _testExecutionEndTime = endTime;
         _terminalWithProgress.StopShowingProgress();
@@ -375,6 +389,7 @@ internal void TestCompleted(
        string? targetFramework,
        string? architecture,
        string? executionId,
+       string testNodeUid,
        string displayName,
        TestOutcome outcome,
        TimeSpan duration,
@@ -391,6 +406,7 @@ internal void TestCompleted(
             targetFramework,
             architecture,
             executionId,
+            testNodeUid,
             displayName,
             outcome,
             duration,
@@ -406,6 +422,7 @@ internal void TestCompleted(
         string? targetFramework,
         string? architecture,
         string? executionId,
+        string testNodeUid,
         string displayName,
         TestOutcome outcome,
         TimeSpan duration,
@@ -417,6 +434,11 @@ internal void TestCompleted(
     {
         TestProgressState asm = _assemblies[$"{assembly}|{targetFramework}|{architecture}|{executionId}"];
 
+        if (_options.ShowActiveTests)
+        {
+            asm.TestNodeResultsState?.RemoveRunningTestNode(testNodeUid);
+        }
+
         switch (outcome)
         {
             case TestOutcome.Error:
@@ -802,7 +824,7 @@ public void ArtifactAdded(bool outOfProcess, string? assembly, string? targetFra
     /// <summary>
     /// Let the user know that cancellation was triggered.
     /// </summary>
-    internal void StartCancelling()
+    public void StartCancelling()
     {
         _wasCancelled = true;
         _terminalWithProgress.WriteToTerminal(terminal =>
@@ -857,7 +879,7 @@ internal void WriteWarningMessage(string assembly, string? targetFramework, stri
     internal void WriteErrorMessage(string assembly, string? targetFramework, string? architecture, string? executionId, Exception exception)
         => WriteErrorMessage(assembly, targetFramework, architecture, executionId, exception.ToString(), padding: null);
 
-    internal void WriteMessage(string text, SystemConsoleColor? color = null, int? padding = null)
+    public void WriteMessage(string text, SystemConsoleColor? color = null, int? padding = null)
     {
         if (color != null)
         {
@@ -980,4 +1002,24 @@ private static TerminalColor ToTerminalColor(ConsoleColor consoleColor)
             ConsoleColor.White => TerminalColor.White,
             _ => TerminalColor.Default,
         };
+
+    public void TestInProgress(
+        string assembly,
+        string? targetFramework,
+        string? architecture,
+        string testNodeUid,
+        string displayName,
+        string? executionId)
+    {
+        TestProgressState asm = _assemblies[$"{assembly}|{targetFramework}|{architecture}|{executionId}"];
+
+        if (_options.ShowActiveTests)
+        {
+            asm.TestNodeResultsState ??= new(Interlocked.Increment(ref _counter));
+            asm.TestNodeResultsState.AddRunningTestNode(
+                Interlocked.Increment(ref _counter), testNodeUid, displayName, CreateStopwatch());
+        }
+
+        _terminalWithProgress.UpdateWorker(asm.SlotIndex);
+    }
 }

src/Platform/Microsoft.Testing.Platform/OutputDevice/Terminal/TerminalTestReporterOptions.cs

@@ -37,6 +37,11 @@ internal sealed class TerminalTestReporterOptions
     /// </summary>
     public Func<bool?> ShowProgress { get; init; } = () => true;
 
+    /// <summary>
+    /// Gets a value indicating whether the active tests should be visible when the progress is shown.
+    /// </summary>
+    public bool ShowActiveTests { get; init; }
+
     /// <summary>
     /// Gets a value indicating whether we should use ANSI escape codes or disable them. When true the capabilities of the console are autodetected.
     /// </summary>

src/Platform/Microsoft.Testing.Platform/OutputDevice/Terminal/TestDetailState.cs

@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Testing.Platform.Helpers;
+
+namespace Microsoft.Testing.Platform.OutputDevice.Terminal;
+
+internal sealed class TestDetailState
+{
+    private string _text;
+
+    public TestDetailState(long id, IStopwatch? stopwatch, string text)
+    {
+        Id = id;
+        Stopwatch = stopwatch;
+        _text = text;
+    }
+
+    public long Id { get; }
+
+    public long Version { get; set; }
+
+    public IStopwatch? Stopwatch { get; }
+
+    public string Text
+    {
+        get => _text;
+        set
+        {
+            if (!_text.Equals(value, StringComparison.Ordinal))
+            {
+                Version++;
+                _text = value;
+            }
+        }
+    }
+}

src/Platform/Microsoft.Testing.Platform/OutputDevice/Terminal/TestNodeResultsState.cs

@@ -0,0 +1,66 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Concurrent;
+using System.Globalization;
+
+using Microsoft.Testing.Platform.Helpers;
+using Microsoft.Testing.Platform.Resources;
+
+namespace Microsoft.Testing.Platform.OutputDevice.Terminal;
+
+internal sealed class TestNodeResultsState
+{
+    public TestNodeResultsState(long id)
+    {
+        Id = id;
+        _summaryDetail = new(id, stopwatch: null, text: string.Empty);
+    }
+
+    public long Id { get; }
+
+    private readonly TestDetailState _summaryDetail;
+    private readonly ConcurrentDictionary<string, TestDetailState> _testNodeProgressStates = new();
+
+    public int Count => _testNodeProgressStates.Count;
+
+    public void AddRunningTestNode(int id, string uid, string name, IStopwatch stopwatch) => _testNodeProgressStates[uid] = new TestDetailState(id, stopwatch, name);
+
+    public void RemoveRunningTestNode(string uid) => _testNodeProgressStates.TryRemove(uid, out _);
+
+    public TestDetailState? GetFirstRunningTask() => _testNodeProgressStates.FirstOrDefault().Value;
+
+    public IEnumerable<TestDetailState> GetRunningTasks(int maxCount)
+    {
+        var sortedDetails = _testNodeProgressStates
+            .Select(d => d.Value)
+            .OrderByDescending(d => d.Stopwatch?.Elapsed ?? TimeSpan.Zero)
+            .ToList();
+
+        bool tooManyItems = sortedDetails.Count > maxCount;
+
+        if (tooManyItems)
+        {
+            // Note: If there's too many items to display, the summary will take up one line.
+            // As such, we can only take maxCount - 1 items.
+            int itemsToTake = maxCount - 1;
+            _summaryDetail.Text =
+                itemsToTake == 0
+                    // Note: If itemsToTake is 0, then we only show two lines, the project summary and the number of running tests.
+                    ? string.Format(CultureInfo.CurrentCulture, PlatformResources.ActiveTestsRunning_FullTestsCount, sortedDetails.Count)
+                    // If itemsToTake is larger, then we show the project summary, active tests, and the number of active tests that are not shown.
+                    : $"... {string.Format(CultureInfo.CurrentCulture, PlatformResources.ActiveTestsRunning_MoreTestsCount, sortedDetails.Count - itemsToTake)}";
+            sortedDetails = sortedDetails.Take(itemsToTake).ToList();
+        }
+
+        foreach (TestDetailState? detail in sortedDetails)
+        {
+            yield return detail;
+        }
+
+        if (tooManyItems)
+        {
+            yield return _summaryDetail;
+        }
+    }
+}

src/Platform/Microsoft.Testing.Platform/OutputDevice/Terminal/TestProgressState.cs

@@ -7,8 +7,9 @@ namespace Microsoft.Testing.Platform.OutputDevice.Terminal;
 
 internal sealed class TestProgressState
 {
-    public TestProgressState(string assembly, string? targetFramework, string? architecture, IStopwatch stopwatch)
+    public TestProgressState(long id, string assembly, string? targetFramework, string? architecture, IStopwatch stopwatch)
     {
+        Id = id;
         Assembly = assembly;
         TargetFramework = targetFramework;
         Architecture = architecture;
@@ -38,11 +39,13 @@ public TestProgressState(string assembly, string? targetFramework, string? archi
 
     public int TotalTests { get; internal set; }
 
-    public string? Detail { get; internal set; }
+    public TestNodeResultsState? TestNodeResultsState { get; internal set; }
 
     public int SlotIndex { get; internal set; }
 
-    public long LastUpdate { get; internal set; }
+    public long Id { get; internal set; }
+
+    public long Version { get; internal set; }
 
     public List<(string? DisplayName, string? UID)> DiscoveredTests { get; internal set; } = new();