Test improvements

Author: tmat

src/BuiltInTools/dotnet-watch/HotReload/CompilationHandler.cs

@@ -88,7 +88,6 @@ public void DiscardProjectBaselines(ImmutableDictionary<ProjectId, string> proje
         public void UpdateProjectBaselines(ImmutableDictionary<ProjectId, string> projectsToBeRebuilt, CancellationToken cancellationToken)
         {
             _hotReloadService.UpdateBaselines(Workspace.CurrentSolution, projectsToBeRebuilt.Keys.ToImmutableArray());
-            _reporter.Report(MessageDescriptor.ProjectBaselinesUpdated);
         }
 
         public async ValueTask StartSessionAsync(CancellationToken cancellationToken)

src/BuiltInTools/dotnet-watch/HotReloadDotNetWatcher.cs

@@ -369,6 +369,8 @@ void FileChangedCallback(ChangedPath change)
 
                             // Update project baselines to reflect changes to the restarted projects.
                             compilationHandler.UpdateProjectBaselines(projectsToRebuild, iterationCancellationToken);
+
+                            Context.Reporter.Report(MessageDescriptor.ProjectsRebuilt, projectsToRebuild.Count);
                         }
 
                         if (projectsToRestart is not [])
@@ -392,6 +394,8 @@ await Task.WhenAll(
                                     }
                                 }))
                                 .WaitAsync(shutdownCancellationToken);
+
+                            Context.Reporter.Report(MessageDescriptor.ProjectsRestarted, projectsToRestart.Length);
                         }
 
                         async Task<ImmutableList<ChangedFile>> CaptureChangedFilesSnapshot(ImmutableDictionary<ProjectId, string>? rebuiltProjects)

src/BuiltInTools/dotnet-watch/Internal/IReporter.cs

@@ -63,7 +63,8 @@ public MessageDescriptor ToErrorWhen(bool condition)
         // predefined messages used for testing:
         public static readonly MessageDescriptor HotReloadSessionStarting = new(Format: null, Emoji: null, MessageSeverity.None, s_id++);
         public static readonly MessageDescriptor HotReloadSessionStarted = new("Hot reload session started.", HotReloadEmoji, MessageSeverity.Verbose, s_id++);
-        public static readonly MessageDescriptor ProjectBaselinesUpdated = new("Project baselines updated.", HotReloadEmoji, MessageSeverity.Verbose, s_id++);
+        public static readonly MessageDescriptor ProjectsRebuilt = new("Projects rebuilt ({0})", HotReloadEmoji, MessageSeverity.Verbose, s_id++);
+        public static readonly MessageDescriptor ProjectsRestarted = new("Projects restarted ({0})", HotReloadEmoji, MessageSeverity.Verbose, s_id++);
         public static readonly MessageDescriptor FixBuildError = new("Fix the error to continue or press Ctrl+C to exit.", WatchEmoji, MessageSeverity.Warning, s_id++);
         public static readonly MessageDescriptor WaitingForChanges = new("Waiting for changes", WatchEmoji, MessageSeverity.Verbose, s_id++);
         public static readonly MessageDescriptor LaunchedProcess = new("Launched '{0}' with arguments '{1}': process id {2}", LaunchEmoji, MessageSeverity.Verbose, s_id++);

test/dotnet-watch.Tests/HotReload/RuntimeProcessLauncherTests.cs

@@ -188,7 +188,7 @@ public async Task UpdateAndRudeEdit(TriggerEvent trigger)
 
         var changeHandled = w.Reporter.RegisterSemaphore(MessageDescriptor.HotReloadChangeHandled);
         var sessionStarted = w.Reporter.RegisterSemaphore(MessageDescriptor.HotReloadSessionStarted);
-        var projectBaselinesUpdated = w.Reporter.RegisterSemaphore(MessageDescriptor.ProjectBaselinesUpdated);
+        var projectBaselinesUpdated = w.Reporter.RegisterSemaphore(MessageDescriptor.ProjectsRebuilt);
         await launchCompletionA.Task;
         await launchCompletionB.Task;
 

test/dotnet-watch.Tests/Utilities/AssertEx.cs

@@ -233,7 +233,7 @@ public static void EqualFileList(IEnumerable<string> expectedFiles, IEnumerable<
             }
         }
 
-        public static void Contains(string expected, IEnumerable<string> items)
+        public static void ContainsSubstring(string expected, IEnumerable<string> items)
         {
             if (items.Any(item => item.Contains(expected)))
             {
@@ -253,8 +253,5 @@ public static void Contains(string expected, IEnumerable<string> items)
 
             Fail(message.ToString());
         }
-
-        public static void DoesNotContain(string expected, IEnumerable<string> items)
-            => Assert.DoesNotContain(expected, items);
     }
 }

test/dotnet-watch.Tests/Watch/Utilities/WatchableApp.cs

@@ -3,9 +3,11 @@
 
 #nullable disable
 
+using System.Runtime.CompilerServices;
+
 namespace Microsoft.DotNet.Watch.UnitTests
 {
-    internal sealed class WatchableApp(ITestOutputHelper logger) : IDisposable
+    internal sealed class WatchableApp(DebugTestOutputLogger logger) : IDisposable
     {
         // Test apps should output this message as soon as they start running:
         private const string StartedMessage = "Started";
@@ -18,7 +20,7 @@ internal sealed class WatchableApp(ITestOutputHelper logger) : IDisposable
 
         public TestFlags TestFlags { get; private set; }
 
-        public ITestOutputHelper Logger => logger;
+        public DebugTestOutputLogger Logger => logger;
 
         public AwaitableProcess Process { get; private set; }
 
@@ -32,32 +34,32 @@ public static string GetLinePrefix(MessageDescriptor descriptor, string projectD
             => $"dotnet watch {descriptor.Emoji}{(projectDisplay != null ? $" [{projectDisplay}]" : "")} {descriptor.Format}";
 
         public void AssertOutputContains(string message)
-            => AssertEx.Contains(message, Process.Output);
+            => AssertEx.ContainsSubstring(message, Process.Output);
 
         public void AssertOutputDoesNotContain(string message)
-            => AssertEx.DoesNotContain(message, Process.Output);
+            => Assert.DoesNotContain(Process.Output, line => line.Contains(message));
 
         public void AssertOutputContains(MessageDescriptor descriptor, string projectDisplay = null)
             => AssertOutputContains(GetLinePrefix(descriptor, projectDisplay));
 
-        public async ValueTask WaitUntilOutputContains(string message)
+        public async ValueTask WaitUntilOutputContains(string message, [CallerFilePath] string testPath = null, [CallerLineNumber] int testLine = 0)
         {
             if (!Process.Output.Any(line => line.Contains(message)))
             {
-                Logger.WriteLine($"[TEST] Test waiting for output: '{message}'");
+                Logger.Log($"Test waiting for output: '{message}'", testPath, testLine);
                 _ = await AssertOutputLine(line => line.Contains(message));
             }
         }
 
-        public Task<string> AssertOutputLineStartsWith(MessageDescriptor descriptor, string projectDisplay = null, Predicate<string> failure = null)
-            => AssertOutputLineStartsWith(GetLinePrefix(descriptor, projectDisplay), failure);
+        public Task<string> AssertOutputLineStartsWith(MessageDescriptor descriptor, string projectDisplay = null, Predicate<string> failure = null, [CallerFilePath] string testPath = null, [CallerLineNumber] int testLine = 0)
+            => AssertOutputLineStartsWith(GetLinePrefix(descriptor, projectDisplay), failure, testPath, testLine);
 
         /// <summary>
         /// Asserts that the watched process outputs a line starting with <paramref name="expectedPrefix"/> and returns the remainder of that line.
         /// </summary>
-        public async Task<string> AssertOutputLineStartsWith(string expectedPrefix, Predicate<string> failure = null)
+        public async Task<string> AssertOutputLineStartsWith(string expectedPrefix, Predicate<string> failure = null, [CallerFilePath] string testPath = null, [CallerLineNumber] int testLine = 0)
         {
-            Logger.WriteLine($"[TEST] Test waiting for output: '{expectedPrefix}'");
+            Logger.Log($"Test waiting for output: '{expectedPrefix}'", testPath, testLine);
 
             var line = await Process.GetOutputLineAsync(
                 success: line => line.StartsWith(expectedPrefix, StringComparison.Ordinal),