Fix fancy zones UI tests #42249 (#44181)

- [ ] Closes: #42249

Contribution to https://github.com/microsoft/PowerToys/issues/40701

src/common/UITestAutomation/ScreenRecording.cs

@@ -0,0 +1,399 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.PowerToys.UITest
+{
+    /// <summary>
+    /// Provides methods for recording the screen during UI tests.
+    /// Requires FFmpeg to be installed and available in PATH.
+    /// </summary>
+    internal class ScreenRecording : IDisposable
+    {
+        private readonly string outputDirectory;
+        private readonly string framesDirectory;
+        private readonly string outputFilePath;
+        private readonly List<string> capturedFrames;
+        private readonly SemaphoreSlim recordingLock = new(1, 1);
+        private readonly Stopwatch recordingStopwatch = new();
+        private readonly string? ffmpegPath;
+        private CancellationTokenSource? recordingCancellation;
+        private Task? recordingTask;
+        private bool isRecording;
+        private int frameCount;
+
+        [DllImport("user32.dll")]
+        private static extern IntPtr GetDC(IntPtr hWnd);
+
+        [DllImport("gdi32.dll")]
+        private static extern int GetDeviceCaps(IntPtr hdc, int nIndex);
+
+        [DllImport("user32.dll")]
+        private static extern IntPtr ReleaseDC(IntPtr hWnd, IntPtr hDC);
+
+        [DllImport("user32.dll")]
+        private static extern bool GetCursorInfo(out ScreenCapture.CURSORINFO pci);
+
+        [DllImport("user32.dll")]
+        private static extern bool DrawIconEx(IntPtr hdc, int x, int y, IntPtr hIcon, int cx, int cy, int istepIfAniCur, IntPtr hbrFlickerFreeDraw, int diFlags);
+
+        private const int CURSORSHOWING = 0x00000001;
+        private const int DESKTOPHORZRES = 118;
+        private const int DESKTOPVERTRES = 117;
+        private const int DINORMAL = 0x0003;
+        private const int TargetFps = 15; // 15 FPS for good balance of quality and size
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ScreenRecording"/> class.
+        /// </summary>
+        /// <param name="outputDirectory">Directory where the recording will be saved.</param>
+        public ScreenRecording(string outputDirectory)
+        {
+            this.outputDirectory = outputDirectory;
+            string timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
+            framesDirectory = Path.Combine(outputDirectory, $"frames_{timestamp}");
+            outputFilePath = Path.Combine(outputDirectory, $"recording_{timestamp}.mp4");
+            capturedFrames = new List<string>();
+            frameCount = 0;
+
+            // Check if FFmpeg is available
+            ffmpegPath = FindFfmpeg();
+            if (ffmpegPath == null)
+            {
+                Console.WriteLine("FFmpeg not found. Screen recording will be disabled.");
+                Console.WriteLine("To enable video recording, install FFmpeg: https://ffmpeg.org/download.html");
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether screen recording is available (FFmpeg found).
+        /// </summary>
+        public bool IsAvailable => ffmpegPath != null;
+
+        /// <summary>
+        /// Starts recording the screen.
+        /// </summary>
+        /// <returns>A task representing the asynchronous operation.</returns>
+        public async Task StartRecordingAsync()
+        {
+            await recordingLock.WaitAsync();
+            try
+            {
+                if (isRecording || !IsAvailable)
+                {
+                    return;
+                }
+
+                // Create frames directory
+                Directory.CreateDirectory(framesDirectory);
+
+                recordingCancellation = new CancellationTokenSource();
+                isRecording = true;
+                recordingStopwatch.Start();
+
+                // Start the recording task
+                recordingTask = Task.Run(() => RecordFrames(recordingCancellation.Token));
+
+                Console.WriteLine($"Started screen recording at {TargetFps} FPS");
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Failed to start recording: {ex.Message}");
+                isRecording = false;
+            }
+            finally
+            {
+                recordingLock.Release();
+            }
+        }
+
+        /// <summary>
+        /// Stops recording and encodes video.
+        /// </summary>
+        /// <returns>A task representing the asynchronous operation.</returns>
+        public async Task StopRecordingAsync()
+        {
+            await recordingLock.WaitAsync();
+            try
+            {
+                if (!isRecording || recordingCancellation == null)
+                {
+                    return;
+                }
+
+                // Signal cancellation
+                recordingCancellation.Cancel();
+
+                // Wait for recording task to complete
+                if (recordingTask != null)
+                {
+                    await recordingTask;
+                }
+
+                recordingStopwatch.Stop();
+                isRecording = false;
+
+                double duration = recordingStopwatch.Elapsed.TotalSeconds;
+                Console.WriteLine($"Recording stopped. Captured {capturedFrames.Count} frames in {duration:F2} seconds");
+
+                // Encode to video
+                await EncodeToVideoAsync();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error stopping recording: {ex.Message}");
+            }
+            finally
+            {
+                Cleanup();
+                recordingLock.Release();
+            }
+        }
+
+        /// <summary>
+        /// Records frames from the screen.
+        /// </summary>
+        private void RecordFrames(CancellationToken cancellationToken)
+        {
+            try
+            {
+                int frameInterval = 1000 / TargetFps;
+                var frameTimer = Stopwatch.StartNew();
+
+                while (!cancellationToken.IsCancellationRequested)
+                {
+                    var frameStart = frameTimer.ElapsedMilliseconds;
+
+                    try
+                    {
+                        CaptureFrame();
+                    }
+                    catch (Exception ex)
+                    {
+                        Console.WriteLine($"Error capturing frame: {ex.Message}");
+                    }
+
+                    // Sleep for remaining time to maintain target FPS
+                    var frameTime = frameTimer.ElapsedMilliseconds - frameStart;
+                    var sleepTime = Math.Max(0, frameInterval - (int)frameTime);
+
+                    if (sleepTime > 0)
+                    {
+                        Thread.Sleep(sleepTime);
+                    }
+                }
+            }
+            catch (OperationCanceledException)
+            {
+                // Expected when stopping
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error during recording: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// Captures a single frame.
+        /// </summary>
+        private void CaptureFrame()
+        {
+            IntPtr hdc = GetDC(IntPtr.Zero);
+            int screenWidth = GetDeviceCaps(hdc, DESKTOPHORZRES);
+            int screenHeight = GetDeviceCaps(hdc, DESKTOPVERTRES);
+            ReleaseDC(IntPtr.Zero, hdc);
+
+            Rectangle bounds = new Rectangle(0, 0, screenWidth, screenHeight);
+            using (Bitmap bitmap = new Bitmap(bounds.Width, bounds.Height, PixelFormat.Format24bppRgb))
+            {
+                using (Graphics g = Graphics.FromImage(bitmap))
+                {
+                    g.CopyFromScreen(bounds.Location, Point.Empty, bounds.Size);
+
+                    ScreenCapture.CURSORINFO cursorInfo;
+                    cursorInfo.CbSize = Marshal.SizeOf<ScreenCapture.CURSORINFO>();
+                    if (GetCursorInfo(out cursorInfo) && cursorInfo.Flags == CURSORSHOWING)
+                    {
+                        IntPtr hdcDest = g.GetHdc();
+                        DrawIconEx(hdcDest, cursorInfo.PTScreenPos.X, cursorInfo.PTScreenPos.Y, cursorInfo.HCursor, 0, 0, 0, IntPtr.Zero, DINORMAL);
+                        g.ReleaseHdc(hdcDest);
+                    }
+                }
+
+                string framePath = Path.Combine(framesDirectory, $"frame_{frameCount:D6}.jpg");
+                bitmap.Save(framePath, ImageFormat.Jpeg);
+                capturedFrames.Add(framePath);
+                frameCount++;
+            }
+        }
+
+        /// <summary>
+        /// Encodes captured frames to video using ffmpeg.
+        /// </summary>
+        private async Task EncodeToVideoAsync()
+        {
+            if (capturedFrames.Count == 0)
+            {
+                Console.WriteLine("No frames captured");
+                return;
+            }
+
+            try
+            {
+                // Build ffmpeg command with proper non-interactive flags
+                string inputPattern = Path.Combine(framesDirectory, "frame_%06d.jpg");
+
+                // -y: overwrite without asking
+                // -nostdin: disable interaction
+                // -loglevel error: only show errors
+                // -stats: show encoding progress
+                string args = $"-y -nostdin -loglevel error -stats -framerate {TargetFps} -i \"{inputPattern}\" -c:v libx264 -pix_fmt yuv420p -crf 23 \"{outputFilePath}\"";
+
+                Console.WriteLine($"Encoding {capturedFrames.Count} frames to video...");
+
+                var startInfo = new ProcessStartInfo
+                {
+                    FileName = ffmpegPath!,
+                    Arguments = args,
+                    UseShellExecute = false,
+                    RedirectStandardOutput = true,
+                    RedirectStandardError = true,
+                    RedirectStandardInput = true, // Important: redirect stdin to prevent hanging
+                    CreateNoWindow = true,
+                };
+
+                using var process = Process.Start(startInfo);
+                if (process != null)
+                {
+                    // Close stdin immediately to ensure FFmpeg doesn't wait for input
+                    process.StandardInput.Close();
+
+                    // Read output streams asynchronously to prevent deadlock
+                    var outputTask = process.StandardOutput.ReadToEndAsync();
+                    var errorTask = process.StandardError.ReadToEndAsync();
+
+                    // Wait for process to exit
+                    await process.WaitForExitAsync();
+
+                    // Get the output
+                    string stdout = await outputTask;
+                    string stderr = await errorTask;
+
+                    if (process.ExitCode == 0 && File.Exists(outputFilePath))
+                    {
+                        var fileInfo = new FileInfo(outputFilePath);
+                        Console.WriteLine($"Video created: {outputFilePath} ({fileInfo.Length / 1024 / 1024:F1} MB)");
+                    }
+                    else
+                    {
+                        Console.WriteLine($"FFmpeg encoding failed with exit code {process.ExitCode}");
+                        if (!string.IsNullOrWhiteSpace(stderr))
+                        {
+                            Console.WriteLine($"FFmpeg error: {stderr}");
+                        }
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error encoding video: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// Finds ffmpeg executable.
+        /// </summary>
+        private static string? FindFfmpeg()
+        {
+            // Check if ffmpeg is in PATH
+            var pathDirs = Environment.GetEnvironmentVariable("PATH")?.Split(Path.PathSeparator) ?? Array.Empty<string>();
+
+            foreach (var dir in pathDirs)
+            {
+                var ffmpegPath = Path.Combine(dir, "ffmpeg.exe");
+                if (File.Exists(ffmpegPath))
+                {
+                    return ffmpegPath;
+                }
+            }
+
+            // Check common installation locations
+            var commonPaths = new[]
+            {
+                @"C:\.tools\ffmpeg\bin\ffmpeg.exe",
+                @"C:\ffmpeg\bin\ffmpeg.exe",
+                @"C:\Program Files\ffmpeg\bin\ffmpeg.exe",
+                @"C:\Program Files (x86)\ffmpeg\bin\ffmpeg.exe",
+                @$"{Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData)}\Microsoft\WinGet\Links\ffmpeg.exe",
+            };
+
+            foreach (var path in commonPaths)
+            {
+                if (File.Exists(path))
+                {
+                    return path;
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Gets the path to the recorded video file.
+        /// </summary>
+        public string OutputFilePath => outputFilePath;
+
+        /// <summary>
+        /// Gets the directory containing recordings.
+        /// </summary>
+        public string OutputDirectory => outputDirectory;
+
+        /// <summary>
+        /// Cleans up resources.
+        /// </summary>
+        private void Cleanup()
+        {
+            recordingCancellation?.Dispose();
+            recordingCancellation = null;
+            recordingTask = null;
+
+            // Clean up frames directory if it exists
+            try
+            {
+                if (Directory.Exists(framesDirectory))
+                {
+                    Directory.Delete(framesDirectory, true);
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Failed to cleanup frames directory: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// Disposes resources.
+        /// </summary>
+        public void Dispose()
+        {
+            if (isRecording)
+            {
+                StopRecordingAsync().GetAwaiter().GetResult();
+            }
+
+            Cleanup();
+            recordingLock.Dispose();
+            GC.SuppressFinalize(this);
+        }
+    }
+}

src/common/UITestAutomation/SessionHelper.cs

@@ -130,9 +130,13 @@ namespace Microsoft.PowerToys.UITest
         /// </summary>
         /// <param name="appPath">The path to the application executable.</param>
         /// <param name="args">Optional command line arguments to pass to the application.</param>
-        public void StartExe(string appPath, string[]? args = null)
+        public void StartExe(string appPath, string[]? args = null, string? enableModules = null)
         {
             var opts = new AppiumOptions();
+            if (!string.IsNullOrEmpty(enableModules))
+            {
+                opts.AddAdditionalCapability("enableModules", enableModules);
+            }
 
             if (scope == PowerToysModule.PowerToysSettings)
             {
@@ -169,27 +173,66 @@ namespace Microsoft.PowerToys.UITest
 
         private void TryLaunchPowerToysSettings(AppiumOptions opts)
         {
-            try
+            if (opts.ToCapabilities().HasCapability("enableModules"))
             {
-                var runnerProcessInfo = new ProcessStartInfo
+                var modulesString = (string)opts.ToCapabilities().GetCapability("enableModules");
+                var modulesArray = modulesString.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+                SettingsConfigHelper.ConfigureGlobalModuleSettings(modulesArray);
+            }
+            else
+            {
+                SettingsConfigHelper.ConfigureGlobalModuleSettings();
+            }
+
+            const int maxTries = 3;
+            const int delayMs = 5000;
+            const int maxRetries = 3;
+
+            for (int tryCount = 1; tryCount <= maxTries; tryCount++)
+            {
+                try
                 {
-                    FileName = locationPath + runnerPath,
-                    Verb = "runas",
-                    Arguments = "--open-settings",
-                };
+                    var runnerProcessInfo = new ProcessStartInfo
+                    {
+                        FileName = locationPath + runnerPath,
+                        Verb = "runas",
+                        Arguments = "--open-settings",
+                    };
 
-                ExitExe(runnerProcessInfo.FileName);
-                runner = Process.Start(runnerProcessInfo);
+                    ExitExe(runnerProcessInfo.FileName);
 
-                WaitForWindowAndSetCapability(opts, "PowerToys Settings", 5000, 5);
+                    // Verify process was killed
+                    string exeName = Path.GetFileNameWithoutExtension(runnerProcessInfo.FileName);
+                    var remainingProcesses = Process.GetProcessesByName(exeName);
 
-                // Exit CmdPal UI before launching new process if use installer for test
-                ExitExeByName("Microsoft.CmdPal.UI");
-            }
-            catch (Exception ex)
-            {
-                throw new InvalidOperationException($"Failed to launch PowerToys Settings: {ex.Message}", ex);
+                    runner = Process.Start(runnerProcessInfo);
+
+                    if (WaitForWindowAndSetCapability(opts, "PowerToys Settings", delayMs, maxRetries))
+                    {
+                        // Exit CmdPal UI before launching new process if use installer for test
+                        ExitExeByName("Microsoft.CmdPal.UI");
+                        return;
+                    }
+
+                    // Window not found, kill all PowerToys processes and retry
+                    if (tryCount < maxTries)
+                    {
+                        KillPowerToysProcesses();
+                    }
+                }
+                catch (Exception ex)
+                {
+                    if (tryCount == maxTries)
+                    {
+                        throw new InvalidOperationException($"Failed to launch PowerToys Settings after {maxTries} attempts: {ex.Message}", ex);
+                    }
+
+                    // Kill processes and retry
+                    KillPowerToysProcesses();
+                }
             }
+
+            throw new InvalidOperationException($"Failed to launch PowerToys Settings: Window not found after {maxTries} attempts.");
         }
 
         private void TryLaunchCommandPalette(AppiumOptions opts)
@@ -211,7 +254,10 @@ namespace Microsoft.PowerToys.UITest
                 var process = Process.Start(processStartInfo);
                 process?.WaitForExit();
 
-                WaitForWindowAndSetCapability(opts, "Command Palette", 5000, 10);
+                if (!WaitForWindowAndSetCapability(opts, "Command Palette", 5000, 10))
+                {
+                    throw new TimeoutException("Failed to find Command Palette window after multiple attempts.");
+                }
             }
             catch (Exception ex)
             {
@@ -219,7 +265,7 @@ namespace Microsoft.PowerToys.UITest
             }
         }
 
-        private void WaitForWindowAndSetCapability(AppiumOptions opts, string windowName, int delayMs, int maxRetries)
+        private bool WaitForWindowAndSetCapability(AppiumOptions opts, string windowName, int delayMs, int maxRetries)
         {
             for (int attempt = 1; attempt <= maxRetries; attempt++)
             {
@@ -230,18 +276,16 @@ namespace Microsoft.PowerToys.UITest
                 {
                     var hexHwnd = window[0].HWnd.ToString("x");
                     opts.AddAdditionalCapability("appTopLevelWindow", hexHwnd);
-                    return;
+                    return true;
                 }
 
                 if (attempt < maxRetries)
                 {
                     Thread.Sleep(delayMs);
                 }
-                else
-                {
-                    throw new TimeoutException($"Failed to find {windowName} window after multiple attempts.");
-                }
             }
+
+            return false;
         }
 
         /// <summary>
@@ -292,17 +336,17 @@ namespace Microsoft.PowerToys.UITest
             catch (Exception ex)
             {
                 // Handle exceptions if needed
-                Debug.WriteLine($"Exception during Cleanup: {ex.Message}");
+                Console.WriteLine($"Exception during Cleanup: {ex.Message}");
             }
         }
 
         /// <summary>
         /// Restarts now exe and takes control of it.
         /// </summary>
-        public void RestartScopeExe()
+        public void RestartScopeExe(string? enableModules = null)
         {
             ExitScopeExe();
-            StartExe(locationPath + sessionPath, this.commandLineArgs);
+            StartExe(locationPath + sessionPath, commandLineArgs, enableModules);
         }
 
         public WindowsDriver<WindowsElement> GetRoot()
@@ -327,5 +371,31 @@ namespace Microsoft.PowerToys.UITest
             this.ExitExe(winAppDriverProcessInfo.FileName);
             SessionHelper.appDriver = Process.Start(winAppDriverProcessInfo);
         }
+
+        private void KillPowerToysProcesses()
+        {
+            var powerToysProcessNames = new[] { "PowerToys", "Microsoft.CmdPal.UI" };
+
+            foreach (var processName in powerToysProcessNames)
+            {
+                try
+                {
+                    var processes = Process.GetProcessesByName(processName);
+
+                    foreach (var process in processes)
+                    {
+                        process.Kill();
+                        process.WaitForExit();
+                    }
+
+                    // Verify processes are actually gone
+                    var remainingProcesses = Process.GetProcessesByName(processName);
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine($"[KillPowerToysProcesses] Failed to kill process {processName}: {ex.Message}");
+                }
+            }
+        }
     }
 }

src/common/UITestAutomation/SettingsConfigHelper.cs

@@ -26,14 +26,13 @@ namespace Microsoft.PowerToys.UITest
         /// <summary>
         /// Configures global PowerToys settings to enable only specified modules and disable all others.
         /// </summary>
-        /// <param name="modulesToEnable">Array of module names to enable (e.g., "Peek", "FancyZones"). All other modules will be disabled.</param>
-        /// <exception cref="ArgumentNullException">Thrown when modulesToEnable is null.</exception>
+        /// <param name="modulesToEnable">Array of module names to enable (e.g., "Peek", "FancyZones"). All other modules will be disabled. If null or empty, all modules will be disabled.</param>
         /// <exception cref="InvalidOperationException">Thrown when settings file operations fail.</exception>
         [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "This is test code and will not be trimmed")]
         [UnconditionalSuppressMessage("AOT", "IL3050", Justification = "This is test code and will not be AOT compiled")]
-        public static void ConfigureGlobalModuleSettings(params string[] modulesToEnable)
+        public static void ConfigureGlobalModuleSettings(params string[]? modulesToEnable)
         {
-            ArgumentNullException.ThrowIfNull(modulesToEnable);
+            modulesToEnable ??= Array.Empty<string>();
 
             try
             {

src/common/UITestAutomation/UITestBase.cs

@@ -29,6 +29,8 @@ namespace Microsoft.PowerToys.UITest
 
         public string? ScreenshotDirectory { get; set; }
 
+        public string? RecordingDirectory { get; set; }
+
         public static MonitorInfoData.ParamsWrapper MonitorInfoData { get; set; } = new MonitorInfoData.ParamsWrapper() { Monitors = new List<MonitorInfoData.MonitorInfoDataWrapper>() };
 
         private readonly PowerToysModule scope;
@@ -36,6 +38,7 @@ namespace Microsoft.PowerToys.UITest
         private readonly string[]? commandLineArgs;
         private SessionHelper? sessionHelper;
         private System.Threading.Timer? screenshotTimer;
+        private ScreenRecording? screenRecording;
 
         public UITestBase(PowerToysModule scope = PowerToysModule.PowerToysSettings, WindowSize size = WindowSize.UnSpecified, string[]? commandLineArgs = null)
         {
@@ -65,12 +68,35 @@ namespace Microsoft.PowerToys.UITest
             CloseOtherApplications();
             if (IsInPipeline)
             {
-                ScreenshotDirectory = Path.Combine(this.TestContext.TestResultsDirectory ?? string.Empty, "UITestScreenshots_" + Guid.NewGuid().ToString());
+                string baseDirectory = this.TestContext.TestResultsDirectory ?? string.Empty;
+                ScreenshotDirectory = Path.Combine(baseDirectory, "UITestScreenshots_" + Guid.NewGuid().ToString());
                 Directory.CreateDirectory(ScreenshotDirectory);
 
+                RecordingDirectory = Path.Combine(baseDirectory, "UITestRecordings_" + Guid.NewGuid().ToString());
+                Directory.CreateDirectory(RecordingDirectory);
+
                 // Take screenshot every 1 second
                 screenshotTimer = new System.Threading.Timer(ScreenCapture.TimerCallback, ScreenshotDirectory, TimeSpan.Zero, TimeSpan.FromMilliseconds(1000));
 
+                // Start screen recording (requires FFmpeg)
+                try
+                {
+                    screenRecording = new ScreenRecording(RecordingDirectory);
+                    if (screenRecording.IsAvailable)
+                    {
+                        _ = screenRecording.StartRecordingAsync();
+                    }
+                    else
+                    {
+                        screenRecording = null;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine($"Failed to start screen recording: {ex.Message}");
+                    screenRecording = null;
+                }
+
                 // Escape Popups before starting
                 System.Windows.Forms.SendKeys.SendWait("{ESC}");
             }
@@ -88,15 +114,36 @@ namespace Microsoft.PowerToys.UITest
             if (IsInPipeline)
             {
                 screenshotTimer?.Change(Timeout.Infinite, Timeout.Infinite);
-                Dispose();
+
+                // Stop screen recording
+                if (screenRecording != null)
+                {
+                    try
+                    {
+                        screenRecording.StopRecordingAsync().GetAwaiter().GetResult();
+                    }
+                    catch (Exception ex)
+                    {
+                        Console.WriteLine($"Failed to stop screen recording: {ex.Message}");
+                    }
+                }
+
                 if (TestContext.CurrentTestOutcome is UnitTestOutcome.Failed
                     or UnitTestOutcome.Error
                     or UnitTestOutcome.Unknown)
                 {
                     Task.Delay(1000).Wait();
                     AddScreenShotsToTestResultsDirectory();
+                    AddRecordingsToTestResultsDirectory();
                     AddLogFilesToTestResultsDirectory();
                 }
+                else
+                {
+                    // Clean up recording if test passed
+                    CleanupRecordingDirectory();
+                }
+
+                Dispose();
             }
 
             this.Session.Cleanup();
@@ -106,6 +153,7 @@ namespace Microsoft.PowerToys.UITest
         public void Dispose()
         {
             screenshotTimer?.Dispose();
+            screenRecording?.Dispose();
             GC.SuppressFinalize(this);
         }
 
@@ -600,6 +648,47 @@ namespace Microsoft.PowerToys.UITest
             }
         }
 
+        /// <summary>
+        /// Adds screen recordings to test results directory when test fails.
+        /// </summary>
+        protected void AddRecordingsToTestResultsDirectory()
+        {
+            if (RecordingDirectory != null && Directory.Exists(RecordingDirectory))
+            {
+                // Add video files (MP4)
+                var videoFiles = Directory.GetFiles(RecordingDirectory, "*.mp4");
+                foreach (string file in videoFiles)
+                {
+                    this.TestContext.AddResultFile(file);
+                    var fileInfo = new FileInfo(file);
+                    Console.WriteLine($"Added video recording: {Path.GetFileName(file)} ({fileInfo.Length / 1024 / 1024:F1} MB)");
+                }
+
+                if (videoFiles.Length == 0)
+                {
+                    Console.WriteLine("No video recording available (FFmpeg not found). Screenshots are still captured.");
+                }
+            }
+        }
+
+        /// <summary>
+        /// Cleans up recording directory when test passes.
+        /// </summary>
+        private void CleanupRecordingDirectory()
+        {
+            if (RecordingDirectory != null && Directory.Exists(RecordingDirectory))
+            {
+                try
+                {
+                    Directory.Delete(RecordingDirectory, true);
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine($"Failed to cleanup recording directory: {ex.Message}");
+                }
+            }
+        }
+
         /// <summary>
         /// Copies PowerToys log files to test results directory when test fails.
         /// Renames files to include the directory structure after \PowerToys.
@@ -689,11 +778,11 @@ namespace Microsoft.PowerToys.UITest
         /// <summary>
         /// Restart scope exe.
         /// </summary>
-        public void RestartScopeExe()
+        public Session RestartScopeExe(string? enableModules = null)
         {
-            this.sessionHelper!.RestartScopeExe();
+            this.sessionHelper!.RestartScopeExe(enableModules);
             this.Session = new Session(this.sessionHelper.GetRoot(), this.sessionHelper.GetDriver(), this.scope, this.size);
-            return;
+            return Session;
         }
 
         /// <summary>