Instrument UI test harness startup

KSemenenko · KSemenenko · commit 95e2b5e5cdf2 · 2026-03-13T10:14:26.000+01:00
diff --git a/DotPilot.UITests/BrowserAutomationBootstrap.cs b/DotPilot.UITests/BrowserAutomationBootstrap.cs
@@ -64,6 +64,7 @@ internal static BrowserAutomationSettings Resolve(
         IReadOnlyList<string> browserBinaryCandidates,
         bool applyEnvironmentVariables = false)
     {
+        HarnessLog.Write("Resolving browser automation settings.");
         var browserBinaryPath = ResolveBrowserBinaryPath(environment, browserBinaryCandidates);
         var driverPath = ResolveBrowserDriverPath(environment, browserBinaryPath);
 
@@ -74,6 +75,8 @@ internal static BrowserAutomationSettings Resolve(
             SetEnvironmentVariableIfMissing(BrowserDriverEnvironmentVariableName, driverPath, environment);
         }
 
+        HarnessLog.Write($"Resolved browser binary path '{browserBinaryPath}'.");
+        HarnessLog.Write($"Resolved browser driver directory '{driverPath}'.");
         return new BrowserAutomationSettings(driverPath, browserBinaryPath);
     }
 
@@ -125,13 +128,18 @@ private static string EnsureChromeDriverDownloaded(string browserBinaryPath)
         var driverDirectory = Path.Combine(cacheRootPath, $"{ChromeDriverBundleNamePrefix}{driverPlatform}");
         var driverExecutablePath = Path.Combine(driverDirectory, GetChromeDriverExecutableFileName());
 
+        HarnessLog.Write($"Browser version '{browserVersion}' resolved for '{browserBinaryPath}'.");
+        HarnessLog.Write($"Matching ChromeDriver version '{driverVersion}' on platform '{driverPlatform}'.");
+
         if (File.Exists(driverExecutablePath))
         {
             EnsureDriverExecutablePermissions(driverExecutablePath);
+            HarnessLog.Write($"Reusing cached ChromeDriver at '{driverExecutablePath}'.");
             return driverDirectory;
         }
 
         Directory.CreateDirectory(cacheRootPath);
+        HarnessLog.Write($"Downloading ChromeDriver to '{cacheRootPath}'.");
         DownloadChromeDriverArchive(driverVersion, driverPlatform, cacheRootPath);
         EnsureDriverExecutablePermissions(driverExecutablePath);
 
@@ -155,9 +163,11 @@ private static void DownloadChromeDriverArchive(string driverVersion, string dri
         }
 
         var downloadUrl = BuildChromeDriverDownloadUrl(driverVersion, driverPlatform, archiveName);
+        HarnessLog.Write($"Fetching ChromeDriver archive '{downloadUrl}'.");
         var archiveBytes = GetResponseBytes(downloadUrl, DriverDownloadFailedMessage);
         File.WriteAllBytes(archivePath, archiveBytes);
         ZipFile.ExtractToDirectory(archivePath, cacheRootPath, overwriteFiles: true);
+        HarnessLog.Write($"Extracted ChromeDriver archive to '{driverDirectory}'.");
     }
 
     private static byte[] GetResponseBytes(string requestUri, string failureMessage)
@@ -287,6 +297,7 @@ private static string ResolveBrowserBinaryPath(
                 !string.IsNullOrWhiteSpace(configuredPath) &&
                 File.Exists(configuredPath))
             {
+                HarnessLog.Write($"Using browser binary from environment variable '{environmentVariableName}'.");
                 return configuredPath;
             }
         }
@@ -295,6 +306,7 @@ private static string ResolveBrowserBinaryPath(
         {
             if (File.Exists(candidatePath))
             {
+                HarnessLog.Write($"Using browser binary candidate '{candidatePath}'.");
                 return candidatePath;
             }
         }
diff --git a/DotPilot.UITests/BrowserTestHost.cs b/DotPilot.UITests/BrowserTestHost.cs
@@ -44,19 +44,23 @@ public static void EnsureStarted(string hostUri)
         {
             if (IsReachable(hostUri))
             {
+                HarnessLog.Write("Browser host is already reachable.");
                 return;
             }
 
             if (_hostProcess is { HasExited: false })
             {
+                HarnessLog.Write("Browser host process already exists. Waiting for readiness.");
                 WaitForHost(hostUri);
                 return;
             }
 
             var repoRoot = FindRepositoryRoot();
             var projectPath = Path.Combine(repoRoot, ProjectRelativePath);
 
+            HarnessLog.Write("Building browser host.");
             EnsureBuilt(repoRoot, projectPath);
+            HarnessLog.Write("Starting browser host process.");
             StartHostProcess(repoRoot, projectPath);
             WaitForHost(hostUri);
         }
@@ -78,6 +82,8 @@ private static void EnsureBuilt(string repoRoot, string projectPath)
         {
             throw new InvalidOperationException($"{BuildFailureMessage} {result.Output}");
         }
+
+        HarnessLog.Write("Browser host build completed.");
     }
 
     private static void StartHostProcess(string repoRoot, string projectPath)
@@ -101,6 +107,7 @@ private static void StartHostProcess(string repoRoot, string projectPath)
         _hostProcess.BeginOutputReadLine();
         _hostProcess.BeginErrorReadLine();
         _startedHost = true;
+        HarnessLog.Write($"Browser host process started with PID {_hostProcess.Id}.");
     }
 
     private static void CaptureOutput(string? line)
@@ -118,6 +125,7 @@ private static void WaitForHost(string hostUri)
         {
             if (IsReachable(hostUri))
             {
+                HarnessLog.Write("Browser host responded to readiness probe.");
                 return;
             }
 
@@ -208,6 +216,7 @@ public static void Stop()
         {
             if (!_startedHost || _hostProcess is null)
             {
+                HarnessLog.Write("Browser host stop requested, but no owned host process is active.");
                 return;
             }
 
@@ -218,13 +227,16 @@ public static void Stop()
 
             try
             {
+                HarnessLog.Write($"Stopping browser host process {hostProcess.Id}.");
                 CancelOutputReaders(hostProcess);
 
                 if (!hostProcess.HasExited)
                 {
                     hostProcess.Kill(entireProcessTree: true);
                     hostProcess.WaitForExit((int)HostShutdownTimeout.TotalMilliseconds);
                 }
+
+                HarnessLog.Write("Browser host process stopped.");
             }
             catch
             {
diff --git a/DotPilot.UITests/HarnessLog.cs b/DotPilot.UITests/HarnessLog.cs
@@ -0,0 +1,13 @@
+namespace DotPilot.UITests;
+
+internal static class HarnessLog
+{
+    private const string Prefix = "[DotPilot.UITests]";
+
+    public static void Write(string message)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(message);
+
+        Console.WriteLine($"{Prefix} {message}");
+    }
+}
diff --git a/DotPilot.UITests/TestBase.cs b/DotPilot.UITests/TestBase.cs
@@ -29,7 +29,12 @@ static TestBase()
     {
         if (Constants.CurrentPlatform == Platform.Browser)
         {
+            HarnessLog.Write($"Browser test target URI is '{Constants.WebAssemblyDefaultUri}'.");
+            HarnessLog.Write($"Browser binary path is '{_browserAutomation!.BrowserBinaryPath}'.");
+            HarnessLog.Write($"Browser driver directory is '{_browserAutomation.DriverPath}'.");
+            HarnessLog.Write("Ensuring browser test host is started.");
             BrowserTestHost.EnsureStarted(Constants.WebAssemblyDefaultUri);
+            HarnessLog.Write("Browser test host is reachable.");
         }
 
         AppInitializer.TestEnvironment.AndroidAppName = Constants.AndroidAppName;
@@ -61,23 +66,29 @@ private set
     [SetUp]
     public void SetUpTest()
     {
+        HarnessLog.Write($"Starting setup for '{TestContext.CurrentContext.Test.Name}'.");
         App = Constants.CurrentPlatform == Platform.Browser
             ? EnsureBrowserApp(_browserAutomation!)
             : AppInitializer.AttachToApp();
+        HarnessLog.Write($"Setup completed for '{TestContext.CurrentContext.Test.Name}'.");
     }
 
     [TearDown]
     public void TearDownTest()
     {
+        HarnessLog.Write($"Starting teardown for '{TestContext.CurrentContext.Test.Name}'.");
         if (_app is not null)
         {
             TakeScreenshot("teardown");
         }
+
+        HarnessLog.Write($"Teardown completed for '{TestContext.CurrentContext.Test.Name}'.");
     }
 
     [OneTimeTearDown]
     public void TearDownFixture()
     {
+        HarnessLog.Write("Starting fixture cleanup.");
         List<Exception> cleanupFailures = [];
 
         if (_app is not null && !ReferenceEquals(_app, _browserApp))
@@ -115,13 +126,17 @@ public void TearDownFixture()
 
         if (cleanupFailures.Count == 1)
         {
+            HarnessLog.Write("Fixture cleanup failed with a single cleanup exception.");
             throw cleanupFailures[0];
         }
 
         if (cleanupFailures.Count > 1)
         {
+            HarnessLog.Write("Fixture cleanup failed with multiple cleanup exceptions.");
             throw new AggregateException(cleanupFailures);
         }
+
+        HarnessLog.Write("Fixture cleanup completed.");
     }
 
     public FileInfo TakeScreenshot(string stepName)
@@ -175,9 +190,11 @@ private static IApp EnsureBrowserApp(BrowserAutomationSettings browserAutomation
         {
             if (_browserApp is not null)
             {
+                HarnessLog.Write("Reusing browser app instance.");
                 return _browserApp;
             }
 
+            HarnessLog.Write("Starting browser app instance.");
             var configurator = Uno.UITest.Selenium.ConfigureApp.WebAssembly
                 .Uri(new Uri(Constants.WebAssemblyDefaultUri))
                 .UsingBrowser(Constants.WebAssemblyBrowser.ToString())
@@ -195,6 +212,7 @@ private static IApp EnsureBrowserApp(BrowserAutomationSettings browserAutomation
             }
 
             _browserApp = configurator.StartApp();
+            HarnessLog.Write("Browser app instance started.");
             return _browserApp;
         }
     }
@@ -203,10 +221,13 @@ private static void TryCleanup(Action cleanupAction, string operationName, List<
     {
         try
         {
+            HarnessLog.Write($"Running cleanup for '{operationName}'.");
             BoundedCleanup.Run(cleanupAction, AppCleanupTimeout, operationName);
+            HarnessLog.Write($"Cleanup completed for '{operationName}'.");
         }
         catch (Exception exception)
         {
+            HarnessLog.Write($"Cleanup failed for '{operationName}': {exception.Message}");
             cleanupFailures.Add(exception);
         }
     }
diff --git a/ui-tests-ci-hang.plan.md b/ui-tests-ci-hang.plan.md
@@ -0,0 +1,113 @@
+# UI Tests CI Hang Plan
+
+## Goal
+
+Fix the `DotPilot.UITests` GitHub Actions execution path so the required UI test job returns a real completed result instead of hanging or being canceled while `Run UI Tests` is still active.
+
+## Scope
+
+### In Scope
+
+- `DotPilot.UITests` harness code and supporting configuration
+- GitHub Actions validation behavior needed to expose or validate the harness fix
+- Durable notes for any repo-level CI implication discovered during the fix
+
+### Out Of Scope
+
+- New product functionality unrelated to UI test stability
+- Weakening, skipping, or conditionally bypassing the UI suite
+- Release workflow changes unrelated to the UI test blocker
+
+## Constraints And Risks
+
+- The UI test suite is mandatory and must stay in the normal validation workflow.
+- A hang, timeout, or canceled run counts as a failing harness outcome.
+- Prefer a deterministic harness fix over workflow-level retries or skip logic.
+- Keep the fix aligned with the current browserwasm test-launch path.
+
+## Testing Methodology
+
+- GitHub baseline:
+  - inspect the active PR run and UI Tests job logs for the actual failure point
+- Local validation:
+  - `dotnet test DotPilot.UITests/DotPilot.UITests.csproj`
+  - any focused repro command needed to exercise the harness shutdown path
+- Broader validation:
+  - `dotnet test DotPilot.slnx`
+  - `dotnet format DotPilot.slnx --verify-no-changes`
+- Quality bar:
+  - UI tests must complete with a terminal pass/fail result locally
+  - the fix must directly address the hang/cancel path instead of hiding it
+
+## Ordered Plan
+
+- [x] Step 1: Capture the current failing GitHub UI test job details and relevant local baseline.
+  Verification:
+  - inspect the active PR workflow run and UI Tests job
+  - run the relevant local UI test command
+  Done when: the concrete hang symptom and likely failing code path are documented below.
+
+- [x] Step 2: Trace the harness launch and shutdown flow in `DotPilot.UITests` to isolate the blocking operation.
+  Verification:
+  - identify the exact code path used during CI teardown or cancellation
+  - document the likely root cause before editing
+  Done when: the intended fix path is clear.
+
+- [x] Step 3: Implement the harness fix and any needed regression coverage.
+  Verification:
+  - changed code remains within repo maintainability limits
+  - local UI test execution still returns a real result
+  Done when: the blocking behavior is removed from the identified path.
+
+- [ ] Step 4: Run final validation and record outcomes.
+  Verification:
+  - `dotnet test DotPilot.UITests/DotPilot.UITests.csproj`
+  - `dotnet test DotPilot.slnx`
+  - `dotnet format DotPilot.slnx --verify-no-changes`
+  - GitHub Actions `UI Test Suite` returns a real completed result with the instrumented harness logs available
+  Done when: required checks are green locally and the GitHub UI test job returns a real completed result or a concrete failing signal.
+
+## Full-Test Baseline Step
+
+- [x] Run the relevant baseline commands after the plan is prepared:
+  - inspect the active GitHub UI Tests job
+  - `dotnet test DotPilot.UITests/DotPilot.UITests.csproj`
+  Done when: the failing symptom is recorded below.
+
+## Failing Tests And Checks Tracker
+
+- [x] `GitHub Actions job: UI Tests`
+  Failure symptom: the PR validation run enters `Run UI Tests`, then fails to produce a terminal result and may later surface `Attempting to cancel the build... Error: The operation was canceled.`
+  Suspected cause: the UI test harness had unbounded teardown calls for `_browserApp.Dispose()` and `BrowserTestHost.Stop()`, so a Windows-specific cleanup hang could leave the job running until GitHub eventually canceled it.
+  Intended fix path: bound teardown cleanup with explicit timeouts and convert cleanup hangs into deterministic test failures instead of infinite jobs.
+  Status: bounded cleanup is fixed locally; CI still needs instrumented logs to confirm whether any remaining hang is in driver/bootstrap, browser startup, host readiness, or teardown.
+
+## Baseline Notes
+
+- PR `#10` currently points at GitHub Actions run `23041255695`, where `Build`, `Unit Tests`, and `Coverage` complete successfully but `UI Tests` stays in progress inside `Run UI Tests`.
+- The affected job is `66920240879`, which started `Run UI Tests` at `2026-03-13T07:50:38Z` and did not produce a terminal result while the other validation jobs finished.
+- A later PR validation run, `23043020124`, shows the same shape so far: `Quality Gate`, `Unit Test Suite`, and `Coverage Suite` completed while `UI Test Suite` job `66925873162` remained `in_progress` inside `Run UI Tests` after starting at `2026-03-13T08:47:49Z`.
+- Local `dotnet test DotPilot.UITests/DotPilot.UITests.csproj` passed before the fix, which indicates the main failure mode is CI-specific hang behavior rather than a consistently failing test case.
+- Local `dotnet test ./DotPilot.UITests/DotPilot.UITests.csproj --logger GitHubActions --blame-crash` also passed before the fix on macOS, which points further toward a Windows-specific teardown or process-cleanup issue.
+
+## Validation Notes
+
+- Added bounded cleanup execution in `DotPilot.UITests` so teardown now fails fast if app disposal or browser-host shutdown hangs.
+- Added focused regression tests for the bounded-cleanup helper to prove success, exception, and timeout behavior.
+- Added harness logging around browser binary resolution, ChromeDriver resolution, host startup, setup, and cleanup so the next GitHub run exposes the exact blocking stage instead of sitting silent inside `Run UI Tests`.
+- `dotnet test DotPilot.UITests/DotPilot.UITests.csproj --filter BoundedCleanupTests` passed.
+- `dotnet test DotPilot.UITests/DotPilot.UITests.csproj` passed with `9` tests green.
+- `dotnet test ./DotPilot.UITests/DotPilot.UITests.csproj --logger GitHubActions --blame-crash` passed with `9` tests green.
+- `dotnet test DotPilot.slnx` passed.
+- `dotnet format DotPilot.slnx --verify-no-changes` passed.
+
+## Final Validation Skills
+
+1. `gh-fix-ci`
+Reason: inspect the failing GitHub Actions run and extract the real failure signal.
+
+2. `mcaf-testing`
+Reason: keep the UI suite mandatory and verified through real execution.
+
+3. `mcaf-dotnet`
+Reason: ensure the harness fix stays aligned with the repo’s .NET toolchain and quality path.

Original file line number	Diff line number	Diff line change
`@@ -64,6 +64,7 @@ internal static BrowserAutomationSettings Resolve(`
`64`	`64`	`IReadOnlyList<string> browserBinaryCandidates,`
`65`	`65`	`bool applyEnvironmentVariables = false)`
`66`	`66`	`{`
	`67`	`+ HarnessLog.Write("Resolving browser automation settings.");`
`67`	`68`	`var browserBinaryPath = ResolveBrowserBinaryPath(environment, browserBinaryCandidates);`
`68`	`69`	`var driverPath = ResolveBrowserDriverPath(environment, browserBinaryPath);`
`69`	`70`
`@@ -74,6 +75,8 @@ internal static BrowserAutomationSettings Resolve(`
`74`	`75`	`SetEnvironmentVariableIfMissing(BrowserDriverEnvironmentVariableName, driverPath, environment);`
`75`	`76`	`}`
`76`	`77`
	`78`	`+ HarnessLog.Write($"Resolved browser binary path '{browserBinaryPath}'.");`
	`79`	`+ HarnessLog.Write($"Resolved browser driver directory '{driverPath}'.");`
`77`	`80`	`return new BrowserAutomationSettings(driverPath, browserBinaryPath);`
`78`	`81`	`}`
`79`	`82`
`@@ -125,13 +128,18 @@ private static string EnsureChromeDriverDownloaded(string browserBinaryPath)`
`125`	`128`	`var driverDirectory = Path.Combine(cacheRootPath, $"{ChromeDriverBundleNamePrefix}{driverPlatform}");`
`126`	`129`	`var driverExecutablePath = Path.Combine(driverDirectory, GetChromeDriverExecutableFileName());`
`127`	`130`
	`131`	`+ HarnessLog.Write($"Browser version '{browserVersion}' resolved for '{browserBinaryPath}'.");`
	`132`	`+ HarnessLog.Write($"Matching ChromeDriver version '{driverVersion}' on platform '{driverPlatform}'.");`
	`133`	`+`
`128`	`134`	`if (File.Exists(driverExecutablePath))`
`129`	`135`	`{`
`130`	`136`	`EnsureDriverExecutablePermissions(driverExecutablePath);`
	`137`	`+ HarnessLog.Write($"Reusing cached ChromeDriver at '{driverExecutablePath}'.");`
`131`	`138`	`return driverDirectory;`
`132`	`139`	`}`
`133`	`140`
`134`	`141`	`Directory.CreateDirectory(cacheRootPath);`
	`142`	`+ HarnessLog.Write($"Downloading ChromeDriver to '{cacheRootPath}'.");`
`135`	`143`	`DownloadChromeDriverArchive(driverVersion, driverPlatform, cacheRootPath);`
`136`	`144`	`EnsureDriverExecutablePermissions(driverExecutablePath);`
`137`	`145`
`@@ -155,9 +163,11 @@ private static void DownloadChromeDriverArchive(string driverVersion, string dri`
`155`	`163`	`}`
`156`	`164`
`157`	`165`	`var downloadUrl = BuildChromeDriverDownloadUrl(driverVersion, driverPlatform, archiveName);`
	`166`	`+ HarnessLog.Write($"Fetching ChromeDriver archive '{downloadUrl}'.");`
`158`	`167`	`var archiveBytes = GetResponseBytes(downloadUrl, DriverDownloadFailedMessage);`
`159`	`168`	`File.WriteAllBytes(archivePath, archiveBytes);`
`160`	`169`	`ZipFile.ExtractToDirectory(archivePath, cacheRootPath, overwriteFiles: true);`
	`170`	`+ HarnessLog.Write($"Extracted ChromeDriver archive to '{driverDirectory}'.");`
`161`	`171`	`}`
`162`	`172`
`163`	`173`	`private static byte[] GetResponseBytes(string requestUri, string failureMessage)`
`@@ -287,6 +297,7 @@ private static string ResolveBrowserBinaryPath(`
`287`	`297`	`!string.IsNullOrWhiteSpace(configuredPath) &&`
`288`	`298`	`File.Exists(configuredPath))`
`289`	`299`	`{`
	`300`	`+ HarnessLog.Write($"Using browser binary from environment variable '{environmentVariableName}'.");`
`290`	`301`	`return configuredPath;`
`291`	`302`	`}`
`292`	`303`	`}`
`@@ -295,6 +306,7 @@ private static string ResolveBrowserBinaryPath(`
`295`	`306`	`{`
`296`	`307`	`if (File.Exists(candidatePath))`
`297`	`308`	`{`
	`309`	`+ HarnessLog.Write($"Using browser binary candidate '{candidatePath}'.");`
`298`	`310`	`return candidatePath;`
`299`	`311`	`}`
`300`	`312`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,19 +44,23 @@ public static void EnsureStarted(string hostUri)`
`44`	`44`	`{`
`45`	`45`	`if (IsReachable(hostUri))`
`46`	`46`	`{`
	`47`	`+ HarnessLog.Write("Browser host is already reachable.");`
`47`	`48`	`return;`
`48`	`49`	`}`
`49`	`50`
`50`	`51`	`if (_hostProcess is { HasExited: false })`
`51`	`52`	`{`
	`53`	`+ HarnessLog.Write("Browser host process already exists. Waiting for readiness.");`
`52`	`54`	`WaitForHost(hostUri);`
`53`	`55`	`return;`
`54`	`56`	`}`
`55`	`57`
`56`	`58`	`var repoRoot = FindRepositoryRoot();`
`57`	`59`	`var projectPath = Path.Combine(repoRoot, ProjectRelativePath);`
`58`	`60`
	`61`	`+ HarnessLog.Write("Building browser host.");`
`59`	`62`	`EnsureBuilt(repoRoot, projectPath);`
	`63`	`+ HarnessLog.Write("Starting browser host process.");`
`60`	`64`	`StartHostProcess(repoRoot, projectPath);`
`61`	`65`	`WaitForHost(hostUri);`
`62`	`66`	`}`
`@@ -78,6 +82,8 @@ private static void EnsureBuilt(string repoRoot, string projectPath)`
`78`	`82`	`{`
`79`	`83`	`throw new InvalidOperationException($"{BuildFailureMessage} {result.Output}");`
`80`	`84`	`}`
	`85`	`+`
	`86`	`+ HarnessLog.Write("Browser host build completed.");`
`81`	`87`	`}`
`82`	`88`
`83`	`89`	`private static void StartHostProcess(string repoRoot, string projectPath)`
`@@ -101,6 +107,7 @@ private static void StartHostProcess(string repoRoot, string projectPath)`
`101`	`107`	`_hostProcess.BeginOutputReadLine();`
`102`	`108`	`_hostProcess.BeginErrorReadLine();`
`103`	`109`	`_startedHost = true;`
	`110`	`+ HarnessLog.Write($"Browser host process started with PID {_hostProcess.Id}.");`
`104`	`111`	`}`
`105`	`112`
`106`	`113`	`private static void CaptureOutput(string? line)`
`@@ -118,6 +125,7 @@ private static void WaitForHost(string hostUri)`
`118`	`125`	`{`
`119`	`126`	`if (IsReachable(hostUri))`
`120`	`127`	`{`
	`128`	`+ HarnessLog.Write("Browser host responded to readiness probe.");`
`121`	`129`	`return;`
`122`	`130`	`}`
`123`	`131`
`@@ -208,6 +216,7 @@ public static void Stop()`
`208`	`216`	`{`
`209`	`217`	`if (!_startedHost \|\| _hostProcess is null)`
`210`	`218`	`{`
	`219`	`+ HarnessLog.Write("Browser host stop requested, but no owned host process is active.");`
`211`	`220`	`return;`
`212`	`221`	`}`
`213`	`222`
`@@ -218,13 +227,16 @@ public static void Stop()`
`218`	`227`
`219`	`228`	`try`
`220`	`229`	`{`
	`230`	`+ HarnessLog.Write($"Stopping browser host process {hostProcess.Id}.");`
`221`	`231`	`CancelOutputReaders(hostProcess);`
`222`	`232`
`223`	`233`	`if (!hostProcess.HasExited)`
`224`	`234`	`{`
`225`	`235`	`hostProcess.Kill(entireProcessTree: true);`
`226`	`236`	`hostProcess.WaitForExit((int)HostShutdownTimeout.TotalMilliseconds);`
`227`	`237`	`}`
	`238`	`+`
	`239`	`+ HarnessLog.Write("Browser host process stopped.");`
`228`	`240`	`}`
`229`	`241`	`catch`
`230`	`242`	`{`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,12 @@ static TestBase()`
`29`	`29`	`{`
`30`	`30`	`if (Constants.CurrentPlatform == Platform.Browser)`
`31`	`31`	`{`
	`32`	`+ HarnessLog.Write($"Browser test target URI is '{Constants.WebAssemblyDefaultUri}'.");`
	`33`	`+ HarnessLog.Write($"Browser binary path is '{_browserAutomation!.BrowserBinaryPath}'.");`
	`34`	`+ HarnessLog.Write($"Browser driver directory is '{_browserAutomation.DriverPath}'.");`
	`35`	`+ HarnessLog.Write("Ensuring browser test host is started.");`
`32`	`36`	`BrowserTestHost.EnsureStarted(Constants.WebAssemblyDefaultUri);`
	`37`	`+ HarnessLog.Write("Browser test host is reachable.");`
`33`	`38`	`}`
`34`	`39`
`35`	`40`	`AppInitializer.TestEnvironment.AndroidAppName = Constants.AndroidAppName;`
`@@ -61,23 +66,29 @@ private set`
`61`	`66`	`[SetUp]`
`62`	`67`	`public void SetUpTest()`
`63`	`68`	`{`
	`69`	`+ HarnessLog.Write($"Starting setup for '{TestContext.CurrentContext.Test.Name}'.");`
`64`	`70`	`App = Constants.CurrentPlatform == Platform.Browser`
`65`	`71`	`? EnsureBrowserApp(_browserAutomation!)`
`66`	`72`	`: AppInitializer.AttachToApp();`
	`73`	`+ HarnessLog.Write($"Setup completed for '{TestContext.CurrentContext.Test.Name}'.");`
`67`	`74`	`}`
`68`	`75`
`69`	`76`	`[TearDown]`
`70`	`77`	`public void TearDownTest()`
`71`	`78`	`{`
	`79`	`+ HarnessLog.Write($"Starting teardown for '{TestContext.CurrentContext.Test.Name}'.");`
`72`	`80`	`if (_app is not null)`
`73`	`81`	`{`
`74`	`82`	`TakeScreenshot("teardown");`
`75`	`83`	`}`
	`84`	`+`
	`85`	`+ HarnessLog.Write($"Teardown completed for '{TestContext.CurrentContext.Test.Name}'.");`
`76`	`86`	`}`
`77`	`87`
`78`	`88`	`[OneTimeTearDown]`
`79`	`89`	`public void TearDownFixture()`
`80`	`90`	`{`
	`91`	`+ HarnessLog.Write("Starting fixture cleanup.");`
`81`	`92`	`List<Exception> cleanupFailures = [];`
`82`	`93`
`83`	`94`	`if (_app is not null && !ReferenceEquals(_app, _browserApp))`
`@@ -115,13 +126,17 @@ public void TearDownFixture()`
`115`	`126`
`116`	`127`	`if (cleanupFailures.Count == 1)`
`117`	`128`	`{`
	`129`	`+ HarnessLog.Write("Fixture cleanup failed with a single cleanup exception.");`
`118`	`130`	`throw cleanupFailures[0];`
`119`	`131`	`}`
`120`	`132`
`121`	`133`	`if (cleanupFailures.Count > 1)`
`122`	`134`	`{`
	`135`	`+ HarnessLog.Write("Fixture cleanup failed with multiple cleanup exceptions.");`
`123`	`136`	`throw new AggregateException(cleanupFailures);`
`124`	`137`	`}`
	`138`	`+`
	`139`	`+ HarnessLog.Write("Fixture cleanup completed.");`
`125`	`140`	`}`
`126`	`141`
`127`	`142`	`public FileInfo TakeScreenshot(string stepName)`
`@@ -175,9 +190,11 @@ private static IApp EnsureBrowserApp(BrowserAutomationSettings browserAutomation`
`175`	`190`	`{`
`176`	`191`	`if (_browserApp is not null)`
`177`	`192`	`{`
	`193`	`+ HarnessLog.Write("Reusing browser app instance.");`
`178`	`194`	`return _browserApp;`
`179`	`195`	`}`
`180`	`196`
	`197`	`+ HarnessLog.Write("Starting browser app instance.");`
`181`	`198`	`var configurator = Uno.UITest.Selenium.ConfigureApp.WebAssembly`
`182`	`199`	`.Uri(new Uri(Constants.WebAssemblyDefaultUri))`
`183`	`200`	`.UsingBrowser(Constants.WebAssemblyBrowser.ToString())`
`@@ -195,6 +212,7 @@ private static IApp EnsureBrowserApp(BrowserAutomationSettings browserAutomation`
`195`	`212`	`}`
`196`	`213`
`197`	`214`	`_browserApp = configurator.StartApp();`
	`215`	`+ HarnessLog.Write("Browser app instance started.");`
`198`	`216`	`return _browserApp;`
`199`	`217`	`}`
`200`	`218`	`}`
`@@ -203,10 +221,13 @@ private static void TryCleanup(Action cleanupAction, string operationName, List<`
`203`	`221`	`{`
`204`	`222`	`try`
`205`	`223`	`{`
	`224`	`+ HarnessLog.Write($"Running cleanup for '{operationName}'.");`
`206`	`225`	`BoundedCleanup.Run(cleanupAction, AppCleanupTimeout, operationName);`
	`226`	`+ HarnessLog.Write($"Cleanup completed for '{operationName}'.");`
`207`	`227`	`}`
`208`	`228`	`catch (Exception exception)`
`209`	`229`	`{`
	`230`	`+ HarnessLog.Write($"Cleanup failed for '{operationName}': {exception.Message}");`
`210`	`231`	`cleanupFailures.Add(exception);`
`211`	`232`	`}`
`212`	`233`	`}`