diff --git a/RepoM.sln b/RepoM.sln
index a7a2738c..4414363e 100644
--- a/RepoM.sln
+++ b/RepoM.sln
@@ -67,6 +67,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RepoM.ActionMenu.Core.TestL
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RepoM.ActionMenu.CodeGenDummyLibrary", "tests\RepoM.ActionMenu.CodeGenDummyLibrary\RepoM.ActionMenu.CodeGenDummyLibrary.csproj", "{998B5CA0-158D-4B01-A343-07ED534D02B0}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UiTests", "tests\UiTests\UiTests.csproj", "{B537DF84-37BC-411F-ABBD-9CBBCE66F0E1}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -681,6 +683,26 @@ Global
 		{998B5CA0-158D-4B01-A343-07ED534D02B0}.Release|x64.Build.0 = Release|Any CPU
 		{998B5CA0-158D-4B01-A343-07ED534D02B0}.Release|x86.ActiveCfg = Release|Any CPU
 		{998B5CA0-158D-4B01-A343-07ED534D02B0}.Release|x86.Build.0 = Release|Any CPU
+		{B537DF84-37BC-411F-ABBD-9CBBCE66F0E1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{B537DF84-37BC-411F-ABBD-9CBBCE66F0E1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{B537DF84-37BC-411F-ABBD-9CBBCE66F0E1}.Debug|ARM.ActiveCfg = Debug|Any CPU
+		{B537DF84-37BC-411F-ABBD-9CBBCE66F0E1}.Debug|ARM.Build.0 = Debug|Any CPU
+		{B537DF84-37BC-411F-ABBD-9CBBCE66F0E1}.Debug|ARM64.ActiveCfg = Debug|Any CPU
+		{B537DF84-37BC-411F-ABBD-9CBBCE66F0E1}.Debug|ARM64.Build.0 = Debug|Any CPU
+		{B537DF84-37BC-411F-ABBD-9CBBCE66F0E1}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{B537DF84-37BC-411F-ABBD-9CBBCE66F0E1}.Debug|x64.Build.0 = Debug|Any CPU
+		{B537DF84-37BC-411F-ABBD-9CBBCE66F0E1}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{B537DF84-37BC-411F-ABBD-9CBBCE66F0E1}.Debug|x86.Build.0 = Debug|Any CPU
+		{B537DF84-37BC-411F-ABBD-9CBBCE66F0E1}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{B537DF84-37BC-411F-ABBD-9CBBCE66F0E1}.Release|Any CPU.Build.0 = Release|Any CPU
+		{B537DF84-37BC-411F-ABBD-9CBBCE66F0E1}.Release|ARM.ActiveCfg = Release|Any CPU
+		{B537DF84-37BC-411F-ABBD-9CBBCE66F0E1}.Release|ARM.Build.0 = Release|Any CPU
+		{B537DF84-37BC-411F-ABBD-9CBBCE66F0E1}.Release|ARM64.ActiveCfg = Release|Any CPU
+		{B537DF84-37BC-411F-ABBD-9CBBCE66F0E1}.Release|ARM64.Build.0 = Release|Any CPU
+		{B537DF84-37BC-411F-ABBD-9CBBCE66F0E1}.Release|x64.ActiveCfg = Release|Any CPU
+		{B537DF84-37BC-411F-ABBD-9CBBCE66F0E1}.Release|x64.Build.0 = Release|Any CPU
+		{B537DF84-37BC-411F-ABBD-9CBBCE66F0E1}.Release|x86.ActiveCfg = Release|Any CPU
+		{B537DF84-37BC-411F-ABBD-9CBBCE66F0E1}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/src/RepoM.App/App.xaml.cs b/src/RepoM.App/App.xaml.cs
index e0b71248..67e8da09 100644
--- a/src/RepoM.App/App.xaml.cs
+++ b/src/RepoM.App/App.xaml.cs
@@ -176,6 +176,7 @@ private static bool IsAlreadyRunning()
             return false;
         }
 
+#pragma warning disable CS0162 // Unreachable code detected
         try
         {
             _mutex = new Mutex(true, "Local\\github.com/coenm/RepoM", out var createdNew);
@@ -193,6 +194,7 @@ private static bool IsAlreadyRunning()
         _mutex.Dispose();
         _mutex = null;
         return true;
+#pragma warning restore CS0162 // Unreachable code detected
     }
 
     private static void ReleaseAndDisposeMutex()
diff --git a/src/RepoM.App/MainWindow.xaml b/src/RepoM.App/MainWindow.xaml
index d4b574cd..08a9136d 100644
--- a/src/RepoM.App/MainWindow.xaml
+++ b/src/RepoM.App/MainWindow.xaml
@@ -33,7 +33,7 @@
 									 Focusable="False">
 
 			<Grid>
-				<TextBlock x:Name="tbNoRepositories"
+				<TextBlock Name="tbNoRepositories"
 						   Text="{DynamicResource EmptyHint}"
 						   TextWrapping="Wrap"
 						   FontSize="15"
@@ -272,8 +272,9 @@
 							Click="UpdateButton_Click" />
 					</Grid>
 
-					<ListBox Name="lstRepositories"
-							 DockPanel.Dock="Top"
+					<ListBox x:Name="lstRepositories"
+                             AutomationProperties.Name="lstRepositories"
+                             DockPanel.Dock="Top"
 							 HorizontalContentAlignment="Stretch"
 							 MouseDoubleClick="LstRepositories_MouseDoubleClick"
 							 KeyDown="LstRepositories_KeyDown"
@@ -373,7 +374,7 @@
 							</DataTemplate>
 						</ListBox.ItemTemplate>
 						<ListBox.ContextMenu>
-							<controls:AcrylicContextMenu x:Name="mnuRepositoryContext" >
+                            <controls:AcrylicContextMenu x:Name="mnuRepositoryContext" >
                                 <!--<controls:AcrylicContextMenu.ItemsPanel>
                                     <ItemsPanelTemplate>
                                         <VirtualizingStackPanel IsVirtualizing="True" VirtualizationMode="Recycling" />
diff --git a/tests/SystemTests/SystemTests.csproj b/tests/SystemTests/SystemTests.csproj
index e72e8a96..0505692a 100644
--- a/tests/SystemTests/SystemTests.csproj
+++ b/tests/SystemTests/SystemTests.csproj
@@ -2,6 +2,11 @@
   <PropertyGroup>
     <TargetFramework>net8.0</TargetFramework>
   </PropertyGroup>
+  <ItemGroup>
+    <Compile Remove="Helpers\**" />
+    <EmbeddedResource Remove="Helpers\**" />
+    <None Remove="Helpers\**" />
+  </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\RepoM.ActionMenu.Core\RepoM.ActionMenu.Core.csproj" />
@@ -27,8 +32,4 @@
     <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
     <PackageReference Include="TUnit" Version="0.1.1030" />
   </ItemGroup>
-
-  <ItemGroup>
-    <Folder Include="Helpers\" />
-  </ItemGroup>
 </Project>
diff --git a/tests/UiTests/ApplicationStartMode.cs b/tests/UiTests/ApplicationStartMode.cs
new file mode 100644
index 00000000..dfc4e521
--- /dev/null
+++ b/tests/UiTests/ApplicationStartMode.cs
@@ -0,0 +1,22 @@
+namespace UiTests;
+
+/// <summary>
+/// Defines how the application under test should be started by the test fixture.
+/// </summary>
+public enum ApplicationStartMode
+{
+    /// <summary>
+    /// Do not start or stop the application as this is done outside.
+    /// </summary>
+    None,
+
+    /// <summary>
+    /// Start the application before each test and close it after each test.
+    /// </summary>
+    OncePerTest,
+
+    /// <summary>
+    /// Start the application once for the whole test fixture and close it when all tests are finished.
+    /// </summary>
+    OncePerFixture
+}
\ No newline at end of file
diff --git a/tests/UiTests/Class1.cs b/tests/UiTests/Class1.cs
new file mode 100644
index 00000000..97955922
--- /dev/null
+++ b/tests/UiTests/Class1.cs
@@ -0,0 +1,116 @@
+namespace UiTests;
+
+using System;
+using System.Threading.Tasks;
+using FlaUI.Core.AutomationElements;
+using FlaUI.Core.Input;
+using FlaUI.Core.WindowsAPI;
+using FlaUI.UIA3;
+using FluentAssertions;
+using UiTests.Extensions;
+using UiTests.Framework;
+using UiTests.RepoM;
+using UiTests.Utils;
+using Xunit;
+using Xunit.Abstractions;
+
+[SetTestName]
+public class NotePadTest
+{
+    private readonly ITestOutputHelper _outputHelper;
+
+    public NotePadTest(ITestOutputHelper outputHelper)
+    {
+        _outputHelper = outputHelper ?? throw new ArgumentNullException(nameof(outputHelper));
+    }
+
+    // make sure no vs code instance is running.
+
+    [Fact]
+    public async Task NotepadLaunchTest()
+    {
+        using var appVsCode = ApplicationFactory.LaunchVsCode(@"C:\Users\Munckhof CJJ\AppData\Roaming\RepoM\RepositoryActionsV2.yaml");
+        using var appRepoM = ApplicationFactory.LaunchRepoM();
+
+        using (var automationRepoM = new UIA3Automation())
+        // using (var automationVsCode = new UIA3Automation())
+        {
+            var automationVsCode = automationRepoM;
+
+            await Task.Delay(20_000);
+            appRepoM.WaitWhileMainHandleIsMissing(TimeSpan.FromSeconds(5));
+            appRepoM.WaitWhileBusy(TimeSpan.FromSeconds(5));
+            appVsCode.WaitWhileMainHandleIsMissing(TimeSpan.FromSeconds(20));
+            appVsCode.WaitWhileBusy(TimeSpan.FromSeconds(20));
+
+            VsCodeWindow vsCodeWindow = appVsCode.GetMainWindow(automationVsCode).As<VsCodeWindow>(_outputHelper);
+            vsCodeWindow.Should().NotBeNull();
+
+            await RepoMWindow.ShowRepoM();
+            await Task.Delay(100);
+
+            await RepoMWindow.KeepRepoMOpenAsync();
+            await Task.Delay(100);
+
+            RepoMWindow repoM = await RepoMWindow.GetRepoMWindowAsync(appRepoM, automationRepoM, _outputHelper);
+
+            // undo keep open
+            await RepoMWindow.KeepRepoMOpenAsync();
+
+            _ = repoM.Hide();
+
+            await Task.Delay(100);
+
+            await vsCodeWindow.FocusUsingMouseAsync();
+
+            vsCodeWindow.NotificationButton.Click();
+            await Task.Delay(100);
+            vsCodeWindow.NotificationButton.Click();
+
+            await vsCodeWindow.FocusActiveEditorGroupAsync();
+            await vsCodeWindow.GoToLineAsync(6);
+
+            Position pos = await vsCodeWindow.GetCurrentCursorPositionAsync(p => p.Line == 6);
+            _outputHelper.WriteLine($"L{pos.Line} C{pos.Column}");
+            pos.Line.Should().Be(6);
+
+            
+            await vsCodeWindow.SelectLineAsync();
+            await Task.Delay(1000);
+            Keyboard.Type(VirtualKeyShort.DELETE);
+            await Task.Delay(1000);
+            Keyboard.Type("end");
+            await Task.Delay(1000);
+            await vsCodeWindow.GoToStartOfLineAsync();
+            await Task.Delay(1000);
+            // await vsCodeWindow.GoToEndOfLineAsync();
+            // Keyboard.Type("Hello World");
+
+            await repoM.ShowAsync();
+            await repoM.SearchTextBox.FocusByMouseAsync();
+            await repoM.SearchTextBox.TypeTextAsync("RepoM", Delays.DefaultKeyPressDelay);
+
+            await Delays.DelayMediumAsync();
+
+
+            repoM.RepositoryList.Items.Should().NotBeEmpty();    
+            ListBoxItem firstItem = repoM.RepositoryList.Items[0];
+
+            await firstItem.MoveMouseAndClick(MouseButton.Right, Delays.DefaultWaitUntilClick);
+            await Delays.DelayMediumAsync();
+
+            var ctxMenuItem = repoM.ContextMenu.Items[1].AsMenuItem();
+            _outputHelper.WriteLine($"ctxMenuItem item text {ctxMenuItem.Text}");
+            await ctxMenuItem.MoveMouseAndClick(MouseButton.Left, Delays.DefaultWaitUntilClick);
+
+            var txt = firstItem.Text;
+            _outputHelper.WriteLine($"Selected item text {txt}");
+
+            repoM.Title.Should().Be("RepoM");
+        }
+
+        await Task.Delay(1000);
+        appRepoM.Close();
+        appVsCode.Close();
+    }
+}
\ No newline at end of file
diff --git a/tests/UiTests/Extensions/AutomationElementExtensionsExtensions.cs b/tests/UiTests/Extensions/AutomationElementExtensionsExtensions.cs
new file mode 100644
index 00000000..62178073
--- /dev/null
+++ b/tests/UiTests/Extensions/AutomationElementExtensionsExtensions.cs
@@ -0,0 +1,89 @@
+namespace UiTests.Extensions;
+
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Threading.Tasks;
+using FlaUI.Core.AutomationElements;
+using FlaUI.Core.Input;
+using UiTests;
+using UiTests.Utils;
+
+public static class AutomationElementExtensionsExtensions
+{
+    public static T As<T>(this AutomationElement self, params object[] args) where T : AutomationElement
+    {
+        if (self == null)
+        {
+            return default!;
+        }
+
+        var args2 = new List<object>
+            {
+                self.FrameworkAutomationElement,
+            };
+        args2.AddRange(args);
+
+        return (T)Activator.CreateInstance(typeof(T), args2.ToArray())!;
+    }
+
+    public static async Task MoveMouseAsync(this AutomationElement element)
+    {
+        Point point = element.GetClickablePoint();
+        await Delays.DelaySmallAsync();
+        Mouse.MoveTo(point);
+        await Delays.DelaySmallAsync();
+    }
+
+    public static async Task MoveMouseAndClick(this AutomationElement element, MouseButton btn = MouseButton.Left, TimeSpan? delayBeforeClick = null)
+    {
+        await element.MoveMouseAsync();
+
+        if (delayBeforeClick.HasValue)
+        {
+            await Task.Delay(delayBeforeClick.Value);
+        }
+
+        Mouse.Click(btn);
+        await Delays.DelaySmallAsync();
+    }
+
+    public static Task FocusByMouseAsync(this AutomationElement element, TimeSpan? delayBeforeClick = null)
+    {
+        return MoveMouseAndClick(element, MouseButton.Left, delayBeforeClick);
+    }
+    
+    public static Task TypeTextAsync(this TextBox textBox, string text)
+    {
+        return textBox.TypeTextAsync(text, TimeSpan.Zero);
+    }
+
+    public static async Task TypeTextAsync(this TextBox textBox, string text, TimeSpan delayBetweenChars)
+    {
+        if (!textBox.IsEnabled)
+        {
+            throw new Exception("TextBox is not enabled");
+        }
+
+        if (text == string.Empty)
+        {
+            await Delays.DelaySmallAsync();
+            return;
+        }
+
+        if (delayBetweenChars > TimeSpan.Zero)
+        {
+            foreach (var character in text)
+            {
+                Keyboard.Type(character);
+                await Task.Delay(delayBetweenChars);
+            }
+        }
+        else
+        {
+            Keyboard.Type(text);
+        }
+
+        await Delays.DelaySmallAsync();
+    }
+}
\ No newline at end of file
diff --git a/tests/UiTests/FlaUiTestBase.cs b/tests/UiTests/FlaUiTestBase.cs
new file mode 100644
index 00000000..20638789
--- /dev/null
+++ b/tests/UiTests/FlaUiTestBase.cs
@@ -0,0 +1,321 @@
+namespace UiTests;
+
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using FlaUI.Core;
+using FlaUI.Core.Capturing;
+using FlaUI.Core.Logging;
+using FlaUI.Core.Tools;
+using UiTests.Framework;
+
+/// <summary>
+/// Base class for ui tests with some helper methods.
+/// This class allows recording videos, taking screenshots on failed tests and
+/// starts and stops the application under test for each test or fixture.
+/// </summary>
+public abstract class FlaUiTestBase
+{
+    /// <summary>
+    /// Member which holds the current video recorder.
+    /// </summary>
+    private VideoRecorder? _recorder;
+
+    /// <summary>
+    /// The name of the current test method. Used for the video recorder.
+    /// </summary>
+    private string _testMethodName;
+
+    /// <summary>
+    /// Instance of the current used automation object.
+    /// </summary>
+    protected AutomationBase Automation { get; private set; }
+
+    /// <summary>
+    /// Instance of the current running application.
+    /// </summary>
+    protected Application Application { get; set; }
+
+    /// <summary>
+    /// Specifies the starting mode of the application to test.
+    /// Defaults to OncePerTest.
+    /// </summary>
+    protected virtual ApplicationStartMode ApplicationStartMode => ApplicationStartMode.OncePerTest;
+
+    /// <summary>
+    /// Flag to indicate if videos should be kept even if the test did not fail.
+    /// Defaults to false.
+    /// </summary>
+    protected virtual bool KeepVideoForSuccessfulTests => false;
+
+    /// <summary>
+    /// Specifies the mode of the video recorder.
+    /// Defaults to OnePerTest.
+    /// </summary>
+    protected virtual VideoRecordingMode VideoRecordingMode => VideoRecordingMode.OnePerTest;
+
+    /// <summary>
+    /// static member which holds the current execution date and time
+    /// </summary> 
+    private static readonly string _testDateTime = DateTime.Now.ToString("yyyyMMddHHmmss");
+
+    /// <summary>
+    /// Path of the directory for the screenshots and videos for the tests.
+    /// Defaults to c:\temp\testsmedia.
+    /// </summary>
+    protected abstract string TestsMediaPath
+    {
+        get;
+        // {
+        //     return $@"c:\temp\testsmedia\{SanitizeFileName(TestContext.CurrentContext.Test.Name)}\{_testDateTime}";
+        // }
+    }
+
+    /// <summary>
+    /// Gets the automation instance that should be used.
+    /// </summary>
+    protected abstract AutomationBase GetAutomation();
+
+    /// <summary>
+    /// Starts the application which should be tested.
+    /// </summary>
+    protected abstract Application StartApplication();
+
+    /// <summary>
+    /// Setup method for the test fixture.
+    /// </summary>
+    // [OneTimeSetUp]
+    public virtual async Task UITestBaseOneTimeSetUp()
+    {
+        // Logger.Default = new NUnitProgressLogger();
+        Automation = GetAutomation();
+        if (VideoRecordingMode == VideoRecordingMode.OnePerFixture)
+        {
+            if (SetTestNameAttribute.TryGet(out var info))
+            {
+                await StartVideoRecorder(SanitizeFileName(info.Name));
+            }
+            else
+            {
+                await StartVideoRecorder(SanitizeFileName("SETUP"));
+            }
+        }
+
+        if (ApplicationStartMode == ApplicationStartMode.OncePerFixture)
+        {
+            Application = StartApplication();
+        }
+    }
+
+    /// <summary>
+    /// Teardown method of the test fixture.
+    /// </summary>
+    // [OneTimeTearDown]
+    public virtual void UITestBaseOneTimeTearDown()
+    {
+        if (VideoRecordingMode == VideoRecordingMode.OnePerFixture)
+        {
+            StopVideoRecorder();
+        }
+
+        if (ApplicationStartMode == ApplicationStartMode.OncePerFixture)
+        {
+            CloseApplication();
+        }
+
+        if (Automation != null)
+        {
+            Automation.Dispose();
+            Automation = null;
+        }
+    }
+
+    /// <summary>
+    /// Setup method for each test.
+    /// </summary>
+    // [SetUp]
+    public virtual async Task UITestBaseSetUp()
+    {
+        // Due to the recorder running in an own thread, it is necessary to save the current method name for that thread
+
+        if (SetTestNameAttribute.TryGet(out var info))
+        {
+            _testMethodName = info.Name;
+        }
+        else
+        {
+            _testMethodName = "SETUP";
+        }
+        
+
+        if (VideoRecordingMode == VideoRecordingMode.OnePerTest)
+        {
+            await StartVideoRecorder(SanitizeFileName(_testMethodName));
+        }
+
+        if (ApplicationStartMode == ApplicationStartMode.OncePerTest)
+        {
+            Application = StartApplication();
+        }
+    }
+
+    /// <summary>
+    /// Teardown method for each test.
+    /// </summary>
+    // [TearDown]
+    public virtual void UITestBaseTearDown()
+    {
+        // if (TestContext.CurrentContext.Result.Outcome.Status == TestStatus.Failed)
+        {
+            TakeScreenShot("COEN");
+            // TestContext.AddTestAttachment(
+            //     CreateScreenShotPath(TestContext.CurrentContext.Test.FullName),
+            //     TestContext.CurrentContext.Test.FullName);
+        }
+
+        if (ApplicationStartMode == ApplicationStartMode.OncePerTest)
+        {
+            CloseApplication();
+        }
+
+        if (VideoRecordingMode == VideoRecordingMode.OnePerTest)
+        {
+            StopVideoRecorder();
+        }
+
+        _testMethodName = null;
+    }
+
+    /// <summary>
+    /// Closes and starts the application.
+    /// </summary>
+    protected void RestartApplication()
+    {
+        CloseApplication();
+        Application = StartApplication();
+    }
+
+    /// <summary>
+    /// Closes the application.
+    /// </summary>
+    private void CloseApplication()
+    {
+        if (Application != null)
+        {
+            Application.Close();
+            Retry.WhileFalse(() => Application.HasExited, TimeSpan.FromSeconds(2), ignoreException: true);
+            Application.Dispose();
+            Application = null;
+        }
+    }
+
+    /// <summary>
+    /// Method which captures the image for the video and screenshots.
+    /// By default captures the main screen.
+    /// </summary>
+    protected virtual CaptureImage CaptureImage()
+    {
+        return Capture.MainScreen();
+    }
+
+    /// <summary>
+    /// Method which allows customizing the settings for the video recorder.
+    /// By default downloads ffmpeg and sets the path to ffmpeg.
+    /// </summary>
+    protected virtual async Task AdjustRecorderSettings(VideoRecorderSettings videoRecorderSettings)
+    {
+        // Download FFMpeg
+        var ffmpegPath = await VideoRecorder.DownloadFFMpeg(@"C:\temp");
+        videoRecorderSettings.ffmpegPath = ffmpegPath;
+    }
+
+    /// <summary>
+    /// Starts the video recorder.
+    /// </summary>
+    /// <param name="videoName">The unique name of the video file.</param>
+    private async Task StartVideoRecorder(string videoName)
+    {
+        // Refresh all the system information
+        SystemInfo.RefreshAll();
+
+        // Start the recorder
+        var videoRecorderSettings = new VideoRecorderSettings
+        {
+            VideoFormat = VideoFormat.xvid,
+            VideoQuality = 6,
+            TargetVideoPath = Path.Combine(TestsMediaPath, $"{SanitizeFileName(videoName)}.avi")
+        };
+        await AdjustRecorderSettings(videoRecorderSettings);
+        _recorder = new VideoRecorder(videoRecorderSettings, r =>
+        {
+            var testName = "[SetUp]";
+            if (SetTestNameAttribute.TryGet(out var info))
+            {
+                testName = info.Name;
+            }
+        
+           
+            var img = CaptureImage();
+            img.ApplyOverlays(new InfoOverlay(img)
+            {
+                RecordTimeSpan = r.RecordTimeSpan,
+                OverlayStringFormat = @"{rt:hh\:mm\:ss\.fff} / {name} / CPU: {cpu} / RAM: {mem.p.used}/{mem.p.tot} ({mem.p.used.perc}) / " + testName
+            }, new MouseOverlay(img));
+            return img;
+        });
+        await Task.Delay(500);
+    }
+
+    /// <summary>
+    /// Stops the video recorder.
+    /// </summary>
+    private void StopVideoRecorder()
+    {
+        if (_recorder != null)
+        {
+            _recorder.Stop();
+            // if (!KeepVideoForSuccessfulTests && TestContext.CurrentContext.Result.FailCount == 0)
+            // {
+            //     File.Delete(_recorder.TargetVideoPath);
+            // }
+            _recorder.Dispose();
+            _recorder = null;
+        }
+    }
+
+    /// <summary>
+    /// Takes a screen shot.
+    /// </summary>
+    private void TakeScreenShot(string testName)
+    {
+        var imagePath = CreateScreenShotPath(testName);
+        try
+        {
+            Directory.CreateDirectory(TestsMediaPath);
+            CaptureImage().ToFile(imagePath);
+        }
+        catch (Exception ex)
+        {
+            Logger.Default.Warn("Failed to save screen shot to directory: {0}, filename: {1}, Ex: {2}", TestsMediaPath, imagePath, ex);
+        }
+    }
+
+    /// <summary>
+    /// Replaces all invalid characters with underlines.
+    /// </summary>
+    private static string SanitizeFileName(string fileName)
+    {
+        fileName = string.Join("_", fileName.Split(Path.GetInvalidFileNameChars()));
+        return fileName;
+    }
+
+    /// <summary>
+    /// Generates full path for screenshot.
+    /// </summary>
+    private string CreateScreenShotPath(string testName)
+    {
+        var imageName = SanitizeFileName(testName) + ".png";
+        imageName = imageName.Replace("\"", string.Empty);
+        return Path.Combine(TestsMediaPath, imageName);
+    }
+}
\ No newline at end of file
diff --git a/tests/UiTests/Framework/SetTestNameAttribute.cs b/tests/UiTests/Framework/SetTestNameAttribute.cs
new file mode 100644
index 00000000..5632624f
--- /dev/null
+++ b/tests/UiTests/Framework/SetTestNameAttribute.cs
@@ -0,0 +1,31 @@
+namespace UiTests.Framework;
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
+using System.Threading;
+using Xunit.Sdk;
+
+[AttributeUsage(AttributeTargets.Class)]
+public class SetTestNameAttribute : BeforeAfterTestAttribute
+{
+    private static readonly AsyncLocal<MethodInfo?> _local = new();
+
+    /// <inheritdoc/>
+    public override void Before(MethodInfo methodUnderTest)
+    {
+        _local.Value = methodUnderTest;
+    }
+
+    /// <inheritdoc/>
+    public override void After(MethodInfo methodUnderTest)
+    {
+        _local.Value = null;
+    }
+
+    internal static bool TryGet([NotNullWhen(true)] out MethodInfo? info)
+    {
+        info = _local.Value;
+        return info != null;
+    }
+}
\ No newline at end of file
diff --git a/tests/UiTests/RepoM.cs b/tests/UiTests/RepoM.cs
new file mode 100644
index 00000000..f88aea12
--- /dev/null
+++ b/tests/UiTests/RepoM.cs
@@ -0,0 +1,71 @@
+// namespace UiTests;
+//
+// using System.Diagnostics;
+// using FlaUI.Core.Input;
+// using FlaUI.Core.WindowsAPI;
+// using FlaUI.Core;
+// using FlaUI.UIA3;
+// using RepoM.ActionMenu.Interface.YamlModel.Templating;
+// using System.Windows.Automation;
+// using FlaUI.Core.Tools;
+// using Xunit;
+//
+// public class CalculatorTests : FlaUiTestBase
+// {
+//     protected override AutomationBase GetAutomation()
+//     {
+//         return new UIA3Automation();
+//     }
+//
+//     // [Fact]
+//     // public void CalculatorTest()
+//     // {
+//     //     var window = Application.GetMainWindow(Automation);
+//     //     var calc = OperatingSystem.IsWindows10() ? (ICalculator)new Win10Calc(window) : new LegacyCalc(window);
+//     //
+//     //     // Switch to default mode
+//     //     System.Threading.Thread.Sleep(1000);
+//     //     Keyboard.TypeSimultaneously(VirtualKeyShort.ALT, VirtualKeyShort.KEY_1);
+//     //     Wait.UntilInputIsProcessed();
+//     //     Application.WaitWhileBusy();
+//     //     System.Threading.Thread.Sleep(1000);
+//     //
+//     //     // Simple addition
+//     //     calc.Button1.Click();
+//     //     calc.Button2.Click();
+//     //     calc.Button3.Click();
+//     //     calc.Button4.Click();
+//     //     calc.ButtonAdd.Click();
+//     //     calc.Button5.Click();
+//     //     calc.Button6.Click();
+//     //     calc.Button7.Click();
+//     //     calc.Button8.Click();
+//     //     calc.ButtonEquals.Click();
+//     //     Application.WaitWhileBusy();
+//     //     var result = calc.Result;
+//     //     // Assert.That(result, Is.EqualTo("6912"));
+//     //
+//     //     // Date comparison
+//     //     using (Keyboard.Pressing(VirtualKeyShort.CONTROL))
+//     //     {
+//     //         Keyboard.Type(VirtualKeyShort.KEY_E);
+//     //     }
+//     // }
+//
+//     protected override Application StartApplication()
+//     {
+//         if (OperatingSystem.IsWindows10())
+//         {
+//             // Use the store application on those systems
+//             return Application.LaunchStoreApp("Microsoft.WindowsCalculator_8wekyb3d8bbwe!App");
+//         }
+//
+//         if (OperatingSystem.IsWindowsServer2016() || OperatingSystem.IsWindowsServer2019())
+//         {
+//             // The calc.exe on this system is just a stub which launches win32calc.exe
+//             return Application.Launch("win32calc.exe");
+//         }
+//
+//         return Application.Launch("calc.exe");
+//     }
+// }
\ No newline at end of file
diff --git a/tests/UiTests/RepoM/RepoMWindow.cs b/tests/UiTests/RepoM/RepoMWindow.cs
new file mode 100644
index 00000000..332a3566
--- /dev/null
+++ b/tests/UiTests/RepoM/RepoMWindow.cs
@@ -0,0 +1,181 @@
+namespace UiTests.RepoM;
+
+using System;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using FlaUI.Core;
+using FlaUI.Core.AutomationElements;
+using FlaUI.Core.Conditions;
+using FlaUI.Core.Definitions;
+using FlaUI.Core.Input;
+using FlaUI.Core.Tools;
+using FlaUI.Core.WindowsAPI;
+using FlaUI.UIA3;
+using FluentAssertions;
+using UiTests.Extensions;
+using UiTests.Utils;
+using Xunit.Abstractions;
+
+public class RepoMWindow : Window
+{
+    private readonly ITestOutputHelper _outputHelper;
+
+    public RepoMWindow(FrameworkAutomationElementBase frameworkAutomationElement, ITestOutputHelper outputHelper)
+        : base(frameworkAutomationElement)
+    {
+        _outputHelper = outputHelper;
+    }
+
+    public bool IsVisible
+    {
+        get
+        {
+            try
+            {
+                var isAvailable = this.IsAvailable;
+                var isEnabled = this.IsEnabled;
+                var isOffscreen = this.IsOffscreen;
+                _outputHelper.WriteLine("Visible:");
+                _outputHelper.WriteLine($" IsAvailable:{isAvailable}");
+                _outputHelper.WriteLine($" IsEnabled:{isEnabled}");
+                _outputHelper.WriteLine($" IsOffscreen:{isOffscreen}");
+                return !isOffscreen;
+            }
+            catch (Exception e)
+            {
+                _outputHelper.WriteLine("Could not determine if RepoM is visible. Returning false. {0}", e.Message);
+                return false;
+            }
+        }
+    }
+
+    public TextBox SearchTextBox
+    {
+        get
+        {
+            TextBox? result = FindFirstDescendant("txtFilter").AsTextBox();
+            result.Should().NotBeNull();
+            return result;
+        }
+    }
+
+    public ListBox RepositoryList
+    {
+        get
+        {
+            ListBox? result = FindFirstDescendant("lstRepositories").AsListBox();
+            result.Should().NotBeNull();
+            return result;
+        }
+    }
+
+    public static Task KeepRepoMOpenAsync()
+    {
+        Keyboard.TypeSimultaneously(VirtualKeyShort.F12);
+        return Task.CompletedTask;
+    }
+
+    public async Task ShowAsync()
+    {
+        if (!IsVisible)
+        {
+            _outputHelper.WriteLine("RepoM is not visible -> Show");
+            // ((Window)this).SetForeground();
+            await ShowRepoM();
+        }
+        else
+        {
+            _outputHelper.WriteLine("RepoM is already visible");
+        }
+
+        await Delays.DelaySmallAsync();
+    }
+
+    public bool Hide()
+    {
+        if (IsVisible)
+        {
+            Focus();
+        }
+
+        var counter = 0;
+        while (IsVisible && counter < 5)
+        {
+            counter++;
+            Keyboard.Type(VirtualKeyShort.ESC);
+        }
+
+        return !IsVisible;
+    }
+    
+    public static async Task ShowRepoM()
+    {
+        Keyboard.TypeSimultaneously(
+            VirtualKeyShort.CONTROL,
+            VirtualKeyShort.ALT,
+            VirtualKeyShort.KEY_R);
+        await Task.Yield();
+    }
+
+    public static async Task<RepoMWindow> GetRepoMWindowAsync(Application app, UIA3Automation automation, ITestOutputHelper outputHelper)
+    {
+        // using var app = FlaUI.Core.Application.Attach(processName);
+        var visibleWindows = automation.GetDesktop();
+
+        app.WaitWhileMainHandleIsMissing(TimeSpan.FromSeconds(5));
+
+        // doesn't work:
+        // var window = visibleWindows.FindFirstChild(cf => cf.ByControlType(ControlType.Window));
+
+        int count = 0;
+
+        AutomationElement[] windows = [];
+
+        while (windows.Length == 0 && count < 10)
+        {
+            count++;
+            windows = visibleWindows.FindAllChildren(e => e.ByProcessId(app.ProcessId)).ToArray();
+            if (windows.Length == 0)
+            {
+                await Task.Delay(500);
+            }
+        }
+
+        windows.Should().HaveCount(1);
+        return windows[0].As<RepoMWindow>(outputHelper);
+    }
+
+    // protected Button ZoomInButton => FindFirstNested(cf => new ConditionBase[] {
+    //         cf.ByControlType(ControlType.StatusBar),
+    //         cf.ByControlType(ControlType.Pane),
+    //         cf.ByText("+")
+    //     }).AsButton();
+    //
+    //
+    // protected TextBox ZoomText => FindFirstNested(cf => new ConditionBase[] {
+    //         cf.ByControlType(ControlType.StatusBar),
+    //         cf.ByControlType(ControlType.Pane),
+    //         cf.ByControlType(ControlType.Text)
+    //     }).AsTextBox();
+
+  
+    // public void ZoomIn()
+    // {
+    //     var currentZoom = ZoomText.Text;
+    //     ZoomInButton.Invoke();
+    //     WaitUntilZoomTextChanged(currentZoom);
+    // }
+    //
+    // public int GetCurrentZoomPercent()
+    // {
+    //     var zoomText = ZoomText.Text;
+    //     var zoomNumberString = Regex.Match(zoomText, @"[0-9]+").ToString();
+    //     return Convert.ToInt32(zoomNumberString);
+    // }
+    //
+    // private void WaitUntilZoomTextChanged(string oldZoomText)
+    // {
+    //     Retry.WhileTrue(() => oldZoomText == ZoomText.Text, timeout: TimeSpan.FromSeconds(1), throwOnTimeout: true, timeoutMessage: "Failed to change zoom");
+    // }
+}
\ No newline at end of file
diff --git a/tests/UiTests/RepoM/VsCodeWindow.cs b/tests/UiTests/RepoM/VsCodeWindow.cs
new file mode 100644
index 00000000..4fcfc41a
--- /dev/null
+++ b/tests/UiTests/RepoM/VsCodeWindow.cs
@@ -0,0 +1,240 @@
+namespace UiTests.RepoM;
+
+using System;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using FlaUI.Core;
+using FlaUI.Core.AutomationElements;
+using FlaUI.Core.Definitions;
+using FlaUI.Core.Input;
+using FlaUI.Core.WindowsAPI;
+using FluentAssertions;
+using UiTests.Utils;
+using Xunit.Abstractions;
+using AutomationElement = FlaUI.Core.AutomationElements.AutomationElement;
+using NotSupportedException = FlaUI.Core.Exceptions.NotSupportedException;
+
+public record Position(int Line, int Column);
+
+public class VsCodeWindow : Window
+{
+    private readonly ITestOutputHelper _outputHelper;
+
+    public VsCodeWindow(FrameworkAutomationElementBase frameworkAutomationElement, ITestOutputHelper outputHelper)
+        : base(frameworkAutomationElement)
+    {
+        _outputHelper = outputHelper ?? throw new ArgumentNullException(nameof(outputHelper));
+    }
+
+    public Position CurrentCursorPosition
+    {
+        get
+        {
+            var selection = StatusBar.FindFirstDescendant("status.editor.selection");
+            selection.Should().NotBeNull();
+
+            var children = selection.FindAllChildren();
+            children.Should().HaveCount(1);
+            
+            var text = children[0].Name.Trim();
+
+            if (string.IsNullOrWhiteSpace(text))
+            {
+                throw new NotSupportedException("Could not find line and column from empty text");
+            }
+
+            // todo, also other type Ln 3, Col 4 (3, 4) stuf.
+            var regex = new Regex("Ln\\s([0-9]+),\\sCol\\s([0-9]+)", RegexOptions.Compiled | RegexOptions.Singleline);
+            Match result = regex.Match(text);
+            if (result.Success)
+            {
+                return new Position(
+                    int.Parse(result.Groups[1].Value),
+                    int.Parse(result.Groups[2].Value));
+            }
+
+            throw new NotSupportedException("Could not find line and column from " + text);
+        }
+    }
+
+    public Button NotificationButton
+    {
+        get
+        {
+            AutomationElement selection = StatusBar.FindFirstDescendant("status.notifications");
+            selection.Should().NotBeNull();
+
+            Button btn = selection.FindFirstChild(cf => cf.ByControlType(ControlType.Button)).AsButton();
+            btn.Should().NotBeNull();
+
+            return btn;
+        }
+    }
+
+    public AutomationElement StatusBar
+    {
+        get
+        {
+            AutomationElement? result = FindFirstDescendant("workbench.parts.statusbar"); // StatusBar
+            result.Should().NotBeNull();
+            return result;
+        }
+    }
+
+    public int Indentation
+    {
+        get
+        {
+            var item = StatusBar.FindFirstDescendant("status.editor.indentiation");
+            // only one child should be present
+            item.FindAllChildren().Should().HaveCount(1);
+            var text = item.FindAllChildren()[0].Name.Trim();
+    
+            _outputHelper.WriteLine("Indentation: " + text);
+    
+            return text.Length; //todo
+        }
+    }
+    
+    public async Task<Position> GetCurrentCursorPositionAsync(Predicate<Position>? untilCheck = null)
+    {
+        Position result = CurrentCursorPosition;
+
+        if (untilCheck == null)
+        {
+            return result;
+        }
+
+        var counter = 0;
+        while (!untilCheck(result) && counter < 100)
+        {
+            _outputHelper.WriteLine($"RETRY ({counter}): {result.Line} {result.Column}");
+            await Task.Delay(5);
+            counter++;
+            try
+            {
+                result = CurrentCursorPosition;
+            }
+            catch (Exception e)
+            {
+                _outputHelper.WriteLine(e.Message);
+            }
+        }
+
+        return result;
+    }
+    
+    public async Task FocusActiveEditorGroupAsync()
+    {
+        await VsCodeOpenCommandPalletAsync();
+        await Task.Delay(5);
+        Keyboard.Type("Focus active editor Group");
+        await Task.Delay(5);
+        Keyboard.Type(VirtualKeyShort.ENTER);
+        await Task.Delay(100);
+    }
+
+    private  Task VsCodeOpenCommandPalletAsync()
+    {
+        Keyboard.TypeSimultaneously(
+            VirtualKeyShort.CONTROL,
+            VirtualKeyShort.SHIFT,
+            VirtualKeyShort.KEY_P);
+        return Task.CompletedTask;
+    }
+
+    public async Task FocusUsingMouseAsync()
+    {
+        this.WaitUntilClickable(TimeSpan.FromSeconds(5));
+
+        if (!this.TryGetClickablePoint(out var p))
+        {
+            throw new InvalidOperationException("Could not get clickable point");
+        }
+
+        Mouse.MovePixelsPerMillisecond *= 3;
+        Mouse.MoveTo(p);
+        await Task.Delay(1000);
+        Mouse.Click();
+        await Task.Delay(1000);
+    }
+
+    public Task GoToLineAsync(int lineNumber)
+    {
+        var pos = CurrentCursorPosition;
+        if (pos.Line == lineNumber)
+        {
+            return Task.CompletedTask;
+        }
+
+        if (Math.Abs(pos.Line - lineNumber) < 5)
+        {
+            return GoToLineUsingArrow(lineNumber);
+        }
+
+        return GoToLineUsingCtrlGAsync(lineNumber);
+        
+    }
+
+    private async Task GoToLineUsingCtrlGAsync(int lineNumber)
+    {
+        Keyboard.TypeSimultaneously(
+            VirtualKeyShort.CONTROL,
+            VirtualKeyShort.KEY_G);
+        await Task.Delay(100);
+        Keyboard.Type(lineNumber.ToString());
+        await Task.Delay(100);
+        Keyboard.Type(VirtualKeyShort.ENTER);
+        await Task.Delay(100);
+    }
+
+    private async Task GoToLineUsingArrow(int lineNumber)
+    {
+        var currentPos = await GetCurrentCursorPositionAsync();
+
+        while (currentPos.Line != lineNumber)
+        {
+            var delta = Math.Abs(currentPos.Line - lineNumber);
+
+            if (currentPos.Line < lineNumber)
+            {
+                for (int i = 0; i < delta; i++)
+                {
+                    Keyboard.Type(VirtualKeyShort.DOWN);
+                    await Task.Delay(20);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < delta; i++)
+                {
+                    Keyboard.Type(VirtualKeyShort.UP);
+                    await Task.Delay(20);
+                }
+            }
+            
+            currentPos = await GetCurrentCursorPositionAsync(c => c.Line == lineNumber);
+        }
+    }
+
+    public Task GoToStartOfLineAsync()
+    {
+        Keyboard.Type(VirtualKeyShort.HOME);
+        return Task.Delay(100);
+    }
+
+    public Task GoToEndOfLineAsync()
+    {
+        Keyboard.Type(VirtualKeyShort.END);
+        return Task.Delay(100);
+    }
+
+    public async Task SelectLineAsync()
+    {
+        Keyboard.Type(VirtualKeyShort.HOME);
+        await Task.Delay(1000);
+        await Delays.DelaySmallAsync();
+        Keyboard.TypeSimultaneously(VirtualKeyShort.SHIFT, VirtualKeyShort.END);
+        await Delays.DelayMediumAsync();
+    }
+}
\ No newline at end of file
diff --git a/tests/UiTests/UiTests.csproj b/tests/UiTests/UiTests.csproj
new file mode 100644
index 00000000..aefb17aa
--- /dev/null
+++ b/tests/UiTests/UiTests.csproj
@@ -0,0 +1,44 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0-windows</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="FakeItEasy" Version="8.3.0" />
+    <PackageReference Include="FakeItEasy.Analyzer.CSharp" Version="6.1.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="FluentAssertions" Version="6.12.1" />
+    <PackageReference Include="FluentAssertions.Analyzers" Version="0.34.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <!-- <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="8.0.2" /> -->
+    <!-- <PackageReference Include="Microsoft.Testing.Extensions.CodeCoverage" Version="17.12.5" /> -->
+    <!-- <PackageReference Include="Microsoft.Testing.Extensions.TrxReport" Version="1.4.1" /> -->
+    <PackageReference Include="System.IO.Abstractions.TestingHelpers" Version="21.0.29" />
+    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
+    <!-- <PackageReference Include="TUnit" Version="0.1.1030" /> -->
+    <PackageReference Include="FlaUI.UIA3" Version="4.0.0" />
+
+    <PackageReference Include="Meziantou.Xunit.ParallelTestFramework" Version="2.3.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="8.0.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="System.IO.Abstractions" Version="21.0.29" />
+    <PackageReference Include="System.IO.Abstractions.TestingHelpers" Version="21.0.29" />
+    <PackageReference Include="Verify.ClipboardAccept" Version="26.6.0" />
+    <PackageReference Include="Verify.Xunit" Version="26.6.0" />
+    <PackageReference Include="xunit" Version="2.9.2" />
+    <PackageReference Include="xunit.categories" Version="2.0.8" />
+    <PackageReference Include="Xunit.EnumMemberData" Version="1.0.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\RepoM.App\RepoM.App.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/tests/UiTests/Utils/ApplicationFactory.cs b/tests/UiTests/Utils/ApplicationFactory.cs
new file mode 100644
index 00000000..27ea464c
--- /dev/null
+++ b/tests/UiTests/Utils/ApplicationFactory.cs
@@ -0,0 +1,27 @@
+namespace UiTests.Utils;
+
+using FlaUI.Core;
+
+public static class ApplicationFactory
+{
+    public static Application LaunchVsCode(string? filename)
+    {
+        if (string.IsNullOrWhiteSpace(filename))
+        {
+            filename = string.Empty;
+        }
+        else
+        {
+            filename = @" """ + filename + @"""";
+        }
+
+        return Application.Launch(
+            @"""C:\Users\Munckhof CJJ\AppData\Local\Programs\Microsoft VS Code\Code.exe""",
+            "--new-window  --disable-extensions" + filename);
+    }
+
+    public static Application LaunchRepoM()
+    {
+        return Application.Launch(@"C:\Projects\Private\git\RepoM\src\RepoM.App\bin\Release\net8.0-windows\RepoM.exe");
+    }
+}
\ No newline at end of file
diff --git a/tests/UiTests/Utils/Delays.cs b/tests/UiTests/Utils/Delays.cs
new file mode 100644
index 00000000..20056a0b
--- /dev/null
+++ b/tests/UiTests/Utils/Delays.cs
@@ -0,0 +1,20 @@
+namespace UiTests.Utils;
+
+using System;
+using System.Threading.Tasks;
+
+public static class Delays
+{
+    public static TimeSpan DefaultKeyPressDelay { get; } = TimeSpan.FromMilliseconds(100);
+    public static TimeSpan DefaultWaitUntilClick { get; } = TimeSpan.FromMilliseconds(1000);
+
+    public static Task DelaySmallAsync()
+    {
+        return Task.Delay(100);
+    }
+
+    public static Task DelayMediumAsync()
+    {
+        return Task.Delay(1000);
+    }
+}
\ No newline at end of file
diff --git a/tests/UiTests/VideoRecordingMode.cs b/tests/UiTests/VideoRecordingMode.cs
new file mode 100644
index 00000000..6be5a02c
--- /dev/null
+++ b/tests/UiTests/VideoRecordingMode.cs
@@ -0,0 +1,22 @@
+namespace UiTests;
+
+/// <summary>
+/// Defines how videos should be recorded for the tests.
+/// </summary>
+public enum VideoRecordingMode
+{
+    /// <summary>
+    /// Do not record any video.
+    /// </summary>
+    NoVideo,
+
+    /// <summary>
+    /// Record one separate video per test.
+    /// </summary>
+    OnePerTest,
+
+    /// <summary>
+    /// Report one video for the whole test fixture.
+    /// </summary>
+    OnePerFixture,
+}
\ No newline at end of file