withoutext

Signed-off-by: Shawn Yuan <shuaiyuan@microsoft.com>

.pipelines/v2/templates/job-build-project.yml

@@ -190,18 +190,11 @@ jobs:
     displayName: Verify ARM64 configurations
 
   - ${{ if eq(parameters.enablePackageCaching, true) }}:
-    - pwsh: |-
-        $dotnetVersion = dotnet --version
-        Write-Host "Current .NET SDK Version: $dotnetVersion"
-        Write-Host "##vso[task.setvariable variable=DotNetSdkVersion]$dotnetVersion"
-      displayName: Get .NET SDK Version for Cache Key
-
     - task: Cache@2
       displayName: 'Cache nuget packages (PackageReference)'
       inputs:
-        key: '"PackageReference" | "$(Agent.OS)" | Directory.Packages.props | "$(DotNetSdkVersion)"'
+        key: '"PackageReference" | "$(Agent.OS)" | Directory.Packages.props'
         restoreKeys: |
-           "PackageReference" | "$(Agent.OS)" | Directory.Packages.props
            "PackageReference" | "$(Agent.OS)"
            "PackageReference"
         path: $(NUGET_PACKAGES)

Directory.Packages.props

@@ -70,6 +70,7 @@
     <PackageVersion Include="NLog.Schema" Version="5.2.8" />
     <PackageVersion Include="OpenAI" Version="2.0.0" />
     <PackageVersion Include="ReverseMarkdown" Version="4.1.0" />
+    <PackageVersion Include="RtfPipe" Version="2.0.7677.4303" />
     <PackageVersion Include="ScipBe.Common.Office.OneNote" Version="3.0.1" />
     <PackageVersion Include="SharpCompress" Version="0.37.2" />
     <!-- Don't update SkiaSharp.Views.WinUI to version 3.* branch as this brakes the HexBox control in Registry Preview. -->

PowerToys.sln

@@ -60,6 +60,9 @@ EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PowerRenameLib", "src\modules\powerrename\lib\PowerRenameLib.vcxproj", "{51920F1F-C28C-4ADF-8660-4238766796C2}"
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PowerRenameTest", "src\modules\powerrename\testapp\PowerRenameTest.vcxproj", "{A3935CF4-46C5-4A88-84D3-6B12E16E6BA2}"
+	ProjectSection(ProjectDependencies) = postProject
+		{51920F1F-C28C-4ADF-8660-4238766796C2} = {51920F1F-C28C-4ADF-8660-4238766796C2}
+	EndProjectSection
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PowerRenameUnitTests", "src\modules\powerrename\unittests\PowerRenameLibUnitTests.vcxproj", "{2151F984-E006-4A9F-92EF-C6DDE3DC8413}"
 	ProjectSection(ProjectDependencies) = postProject
@@ -741,15 +744,13 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.CmdPal.Core.ViewM
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.CmdPal.UITests", "src\modules\cmdpal\Microsoft.CmdPal.UITests\Microsoft.CmdPal.UITests.csproj", "{840455DF-5634-51BB-D937-9D7D32F0B0C2}"
 EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Tests", "Tests", "{15EA681E-C7D8-13C7-8484-4AC65E1B71E8}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UITest-Settings", "src\settings-ui\UITest-Settings\UITest-Settings.csproj", "{129A8FCD-CB54-4AD1-AC42-2BFCE159107A}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.CmdPal.Ext.Registry.UnitTests", "src\modules\cmdpal\Tests\Microsoft.CmdPal.Ext.Registry.UnitTests\Microsoft.CmdPal.Ext.Registry.UnitTests.csproj", "{2CF0567E-1E00-4E3F-1561-BF85F5CE5FE7}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UITest-ColorPicker", "src\modules\colorPicker\UITest-ColorPicker\UITest-ColorPicker.csproj", "{E4BAAD93-A499-42FD-A741-7E9591594B61}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.CmdPal.Ext.System.UnitTests", "src\modules\cmdpal\Tests\Microsoft.CmdPal.Ext.System.UnitTests\Microsoft.CmdPal.Ext.System.UnitTests.csproj", "{790247CB-2B95-E139-E933-09D10137EEAF}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AdvancedPaste-UITests", "src\modules\AdvancedPaste\UITest-AdvancedPaste\AdvancedPaste-UITests.csproj", "{2B1505FA-132A-460B-B22B-7CC3FFAB0C5D}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.CmdPal.Ext.TimeDate.UnitTests", "src\modules\cmdpal\Tests\Microsoft.CmdPal.Ext.TimeDate.UnitTests\Microsoft.CmdPal.Ext.TimeDate.UnitTests.csproj", "{18525614-CDB2-8BBE-B1B4-3812CD990C22}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.CmdPal.Ext.WindowWalker.UnitTests", "src\modules\cmdpal\Tests\Microsoft.CmdPal.Ext.WindowWalker.UnitTests\Microsoft.CmdPal.Ext.WindowWalker.UnitTests.csproj", "{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8}"
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Tests", "Tests", "{9B3962F4-AB69-4C2A-8917-2C8448AC6960}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -2733,14 +2734,6 @@ Global
 		{14AFD976-B4D2-49D0-9E6C-AA93CC061B8A}.Release|ARM64.Build.0 = Release|ARM64
 		{14AFD976-B4D2-49D0-9E6C-AA93CC061B8A}.Release|x64.ActiveCfg = Release|x64
 		{14AFD976-B4D2-49D0-9E6C-AA93CC061B8A}.Release|x64.Build.0 = Release|x64
-		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Debug|ARM64.ActiveCfg = Debug|ARM64
-		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Debug|ARM64.Build.0 = Debug|ARM64
-		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Debug|x64.ActiveCfg = Debug|x64
-		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Debug|x64.Build.0 = Debug|x64
-		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Release|ARM64.ActiveCfg = Release|ARM64
-		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Release|ARM64.Build.0 = Release|ARM64
-		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Release|x64.ActiveCfg = Release|x64
-		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Release|x64.Build.0 = Release|x64
 		{9D3F3793-EFE3-4525-8782-238015DABA62}.Debug|ARM64.ActiveCfg = Debug|ARM64
 		{9D3F3793-EFE3-4525-8782-238015DABA62}.Debug|ARM64.Build.0 = Debug|ARM64
 		{9D3F3793-EFE3-4525-8782-238015DABA62}.Debug|x64.ActiveCfg = Debug|x64
@@ -2757,6 +2750,14 @@ Global
 		{BCDC7246-F4F8-4EED-8DE6-037AA2E7C6D1}.Release|ARM64.Build.0 = Release|ARM64
 		{BCDC7246-F4F8-4EED-8DE6-037AA2E7C6D1}.Release|x64.ActiveCfg = Release|x64
 		{BCDC7246-F4F8-4EED-8DE6-037AA2E7C6D1}.Release|x64.Build.0 = Release|x64
+		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Debug|ARM64.Build.0 = Debug|ARM64
+		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Debug|x64.ActiveCfg = Debug|x64
+		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Debug|x64.Build.0 = Debug|x64
+		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Release|ARM64.ActiveCfg = Release|ARM64
+		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Release|ARM64.Build.0 = Release|ARM64
+		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Release|x64.ActiveCfg = Release|x64
+		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027}.Release|x64.Build.0 = Release|x64
 		{840455DF-5634-51BB-D937-9D7D32F0B0C2}.Debug|ARM64.ActiveCfg = Debug|ARM64
 		{840455DF-5634-51BB-D937-9D7D32F0B0C2}.Debug|ARM64.Build.0 = Debug|ARM64
 		{840455DF-5634-51BB-D937-9D7D32F0B0C2}.Debug|x64.ActiveCfg = Debug|x64
@@ -2765,38 +2766,30 @@ Global
 		{840455DF-5634-51BB-D937-9D7D32F0B0C2}.Release|ARM64.Build.0 = Release|ARM64
 		{840455DF-5634-51BB-D937-9D7D32F0B0C2}.Release|x64.ActiveCfg = Release|x64
 		{840455DF-5634-51BB-D937-9D7D32F0B0C2}.Release|x64.Build.0 = Release|x64
-		{2CF0567E-1E00-4E3F-1561-BF85F5CE5FE7}.Debug|ARM64.ActiveCfg = Debug|ARM64
-		{2CF0567E-1E00-4E3F-1561-BF85F5CE5FE7}.Debug|ARM64.Build.0 = Debug|ARM64
-		{2CF0567E-1E00-4E3F-1561-BF85F5CE5FE7}.Debug|x64.ActiveCfg = Debug|x64
-		{2CF0567E-1E00-4E3F-1561-BF85F5CE5FE7}.Debug|x64.Build.0 = Debug|x64
-		{2CF0567E-1E00-4E3F-1561-BF85F5CE5FE7}.Release|ARM64.ActiveCfg = Release|ARM64
-		{2CF0567E-1E00-4E3F-1561-BF85F5CE5FE7}.Release|ARM64.Build.0 = Release|ARM64
-		{2CF0567E-1E00-4E3F-1561-BF85F5CE5FE7}.Release|x64.ActiveCfg = Release|x64
-		{2CF0567E-1E00-4E3F-1561-BF85F5CE5FE7}.Release|x64.Build.0 = Release|x64
-		{790247CB-2B95-E139-E933-09D10137EEAF}.Debug|ARM64.ActiveCfg = Debug|ARM64
-		{790247CB-2B95-E139-E933-09D10137EEAF}.Debug|ARM64.Build.0 = Debug|ARM64
-		{790247CB-2B95-E139-E933-09D10137EEAF}.Debug|x64.ActiveCfg = Debug|x64
-		{790247CB-2B95-E139-E933-09D10137EEAF}.Debug|x64.Build.0 = Debug|x64
-		{790247CB-2B95-E139-E933-09D10137EEAF}.Release|ARM64.ActiveCfg = Release|ARM64
-		{790247CB-2B95-E139-E933-09D10137EEAF}.Release|ARM64.Build.0 = Release|ARM64
-		{790247CB-2B95-E139-E933-09D10137EEAF}.Release|x64.ActiveCfg = Release|x64
-		{790247CB-2B95-E139-E933-09D10137EEAF}.Release|x64.Build.0 = Release|x64
-		{18525614-CDB2-8BBE-B1B4-3812CD990C22}.Debug|ARM64.ActiveCfg = Debug|ARM64
-		{18525614-CDB2-8BBE-B1B4-3812CD990C22}.Debug|ARM64.Build.0 = Debug|ARM64
-		{18525614-CDB2-8BBE-B1B4-3812CD990C22}.Debug|x64.ActiveCfg = Debug|x64
-		{18525614-CDB2-8BBE-B1B4-3812CD990C22}.Debug|x64.Build.0 = Debug|x64
-		{18525614-CDB2-8BBE-B1B4-3812CD990C22}.Release|ARM64.ActiveCfg = Release|ARM64
-		{18525614-CDB2-8BBE-B1B4-3812CD990C22}.Release|ARM64.Build.0 = Release|ARM64
-		{18525614-CDB2-8BBE-B1B4-3812CD990C22}.Release|x64.ActiveCfg = Release|x64
-		{18525614-CDB2-8BBE-B1B4-3812CD990C22}.Release|x64.Build.0 = Release|x64
-		{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8}.Debug|ARM64.ActiveCfg = Debug|ARM64
-		{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8}.Debug|ARM64.Build.0 = Debug|ARM64
-		{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8}.Debug|x64.ActiveCfg = Debug|x64
-		{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8}.Debug|x64.Build.0 = Debug|x64
-		{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8}.Release|ARM64.ActiveCfg = Release|ARM64
-		{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8}.Release|ARM64.Build.0 = Release|ARM64
-		{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8}.Release|x64.ActiveCfg = Release|x64
-		{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8}.Release|x64.Build.0 = Release|x64
+		{129A8FCD-CB54-4AD1-AC42-2BFCE159107A}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{129A8FCD-CB54-4AD1-AC42-2BFCE159107A}.Debug|ARM64.Build.0 = Debug|ARM64
+		{129A8FCD-CB54-4AD1-AC42-2BFCE159107A}.Debug|x64.ActiveCfg = Debug|x64
+		{129A8FCD-CB54-4AD1-AC42-2BFCE159107A}.Debug|x64.Build.0 = Debug|x64
+		{129A8FCD-CB54-4AD1-AC42-2BFCE159107A}.Release|ARM64.ActiveCfg = Release|ARM64
+		{129A8FCD-CB54-4AD1-AC42-2BFCE159107A}.Release|ARM64.Build.0 = Release|ARM64
+		{129A8FCD-CB54-4AD1-AC42-2BFCE159107A}.Release|x64.ActiveCfg = Release|x64
+		{129A8FCD-CB54-4AD1-AC42-2BFCE159107A}.Release|x64.Build.0 = Release|x64
+		{E4BAAD93-A499-42FD-A741-7E9591594B61}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{E4BAAD93-A499-42FD-A741-7E9591594B61}.Debug|ARM64.Build.0 = Debug|ARM64
+		{E4BAAD93-A499-42FD-A741-7E9591594B61}.Debug|x64.ActiveCfg = Debug|x64
+		{E4BAAD93-A499-42FD-A741-7E9591594B61}.Debug|x64.Build.0 = Debug|x64
+		{E4BAAD93-A499-42FD-A741-7E9591594B61}.Release|ARM64.ActiveCfg = Release|ARM64
+		{E4BAAD93-A499-42FD-A741-7E9591594B61}.Release|ARM64.Build.0 = Release|ARM64
+		{E4BAAD93-A499-42FD-A741-7E9591594B61}.Release|x64.ActiveCfg = Release|x64
+		{E4BAAD93-A499-42FD-A741-7E9591594B61}.Release|x64.Build.0 = Release|x64
+		{2B1505FA-132A-460B-B22B-7CC3FFAB0C5D}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{2B1505FA-132A-460B-B22B-7CC3FFAB0C5D}.Debug|ARM64.Build.0 = Debug|ARM64
+		{2B1505FA-132A-460B-B22B-7CC3FFAB0C5D}.Debug|x64.ActiveCfg = Debug|x64
+		{2B1505FA-132A-460B-B22B-7CC3FFAB0C5D}.Debug|x64.Build.0 = Debug|x64
+		{2B1505FA-132A-460B-B22B-7CC3FFAB0C5D}.Release|ARM64.ActiveCfg = Release|ARM64
+		{2B1505FA-132A-460B-B22B-7CC3FFAB0C5D}.Release|ARM64.Build.0 = Release|ARM64
+		{2B1505FA-132A-460B-B22B-7CC3FFAB0C5D}.Release|x64.ActiveCfg = Release|x64
+		{2B1505FA-132A-460B-B22B-7CC3FFAB0C5D}.Release|x64.Build.0 = Release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -3054,8 +3047,8 @@ Global
 		{3A9A7297-92C4-4F16-B6F9-8D4AB652C86C} = {ECB8E0D1-7603-4E5C-AB10-D1E545E6F8E2}
 		{605E914B-7232-4789-AF46-BF5D3DDFC14E} = {ECB8E0D1-7603-4E5C-AB10-D1E545E6F8E2}
 		{E81A7D20-9862-ABDB-0AAE-9BC5B517A9F9} = {ECB8E0D1-7603-4E5C-AB10-D1E545E6F8E2}
-		{D5E5F5EA-1B6C-4A73-88BE-304F36C9E4EE} = {9873BA05-4C41-4819-9283-CF45D795431B}
-		{7F5B9557-5878-4438-A721-3E28296BA193} = {9873BA05-4C41-4819-9283-CF45D795431B}
+		{D5E5F5EA-1B6C-4A73-88BE-304F36C9E4EE} = {9B3962F4-AB69-4C2A-8917-2C8448AC6960}
+		{7F5B9557-5878-4438-A721-3E28296BA193} = {9B3962F4-AB69-4C2A-8917-2C8448AC6960}
 		{DD6E12FE-5509-4ABC-ACC2-3D6DC98A238C} = {4574FDD0-F61D-4376-98BF-E5A1262C11EC}
 		{0A84F764-3A88-44CD-AA96-41BDBD48627B} = {DD6E12FE-5509-4ABC-ACC2-3D6DC98A238C}
 		{E4585179-2AC1-4D5F-A3FF-CFC5392F694C} = {DD6E12FE-5509-4ABC-ACC2-3D6DC98A238C}
@@ -3081,16 +3074,15 @@ Global
 		{43E779F3-D83C-48B1-BA8D-1912DBD76FC9} = {A2221D7E-55E7-4BEA-90D1-4F162D670BBF}
 		{2CF78CF7-8FEB-4BE1-9591-55FA25B48FC6} = {1AFB6476-670D-4E80-A464-657E01DFF482}
 		{14AFD976-B4D2-49D0-9E6C-AA93CC061B8A} = {1AFB6476-670D-4E80-A464-657E01DFF482}
-		{02EA681E-C7D8-13C7-8484-4AC65E1B71E8} = {3846508C-77EB-4034-A702-F8BB263C4F79}
-		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
 		{9D3F3793-EFE3-4525-8782-238015DABA62} = {89E20BCE-EB9C-46C8-8B50-E01A82E6FDC3}
 		{BCDC7246-F4F8-4EED-8DE6-037AA2E7C6D1} = {17B4FA70-001E-4D33-BBBB-0D142DBC2E20}
+		{02EA681E-C7D8-13C7-8484-4AC65E1B71E8} = {3846508C-77EB-4034-A702-F8BB263C4F79}
+		{24133F7F-C1D1-DE04-EFA8-F5D5467FE027} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
 		{840455DF-5634-51BB-D937-9D7D32F0B0C2} = {7520A2FE-00A2-49B8-83ED-DB216E874C04}
-		{15EA681E-C7D8-13C7-8484-4AC65E1B71E8} = {3846508C-77EB-4034-A702-F8BB263C4F79}
-		{2CF0567E-1E00-4E3F-1561-BF85F5CE5FE7} = {15EA681E-C7D8-13C7-8484-4AC65E1B71E8}
-		{790247CB-2B95-E139-E933-09D10137EEAF} = {15EA681E-C7D8-13C7-8484-4AC65E1B71E8}
-		{18525614-CDB2-8BBE-B1B4-3812CD990C22} = {15EA681E-C7D8-13C7-8484-4AC65E1B71E8}
-		{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8} = {15EA681E-C7D8-13C7-8484-4AC65E1B71E8}
+		{129A8FCD-CB54-4AD1-AC42-2BFCE159107A} = {C3081D9A-1586-441A-B5F4-ED815B3719C1}
+		{E4BAAD93-A499-42FD-A741-7E9591594B61} = {1D78B84B-CA39-406C-98F4-71F7EC266CC0}
+		{2B1505FA-132A-460B-B22B-7CC3FFAB0C5D} = {9B3962F4-AB69-4C2A-8917-2C8448AC6960}
+		{9B3962F4-AB69-4C2A-8917-2C8448AC6960} = {9873BA05-4C41-4819-9283-CF45D795431B}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {C3A2F9D1-7930-4EF4-A6FC-7EE0A99821D0}

src/codeAnalysis/GlobalSuppressions.cs

@@ -120,3 +120,5 @@ using System.Diagnostics.CodeAnalysis;
 [assembly: SuppressMessage("StyleCop.CSharp.SpacingRules", "SA1025:Code should not contain multiple whitespace in a row", Justification = "<Code port with style preservation>", Scope = "namespaceanddescendants", Target = "RegistryPreviewUILib.HexBox")]
 [assembly: SuppressMessage("StyleCop.CSharp.SpacingRules", "SA1028:Code should not contain trailing whitespace", Justification = "<Code port with style preservation>", Scope = "namespaceanddescendants", Target = "RegistryPreviewUILib.HexBox")]
 [assembly: SuppressMessage("Usage", "CsWinRT1028:Class is not marked partial", Justification = "<Code port with style preservation>", Scope = "namespaceanddescendants", Target = "RegistryPreviewUILib.HexBox")]
+[assembly: SuppressMessage("Globalization", "CA1305:Specify IFormatProvider", Justification = "none", Scope = "member", Target = "~M:Microsoft.AdvancedPaste.UITests.WordManager.PasteTextToTarget(System.Int32)")]
+[assembly: SuppressMessage("Globalization", "CA1305:Specify IFormatProvider", Justification = "none", Scope = "member", Target = "~M:Microsoft.AdvancedPaste.UITests.WordManager.CopyTextFromSource(System.Int32,System.Int32)~System.String")]

src/common/UITestAutomation/Element/ComboBox.cs

@@ -24,5 +24,16 @@ namespace Microsoft.PowerToys.UITest
         {
             this.Find<NavigationViewItem>(value).Click();
         }
+
+        /// <summary>
+        /// Select a text item from the ComboBox.
+        /// </summary>
+        /// <param name="value">The text to select from the ComboBox.</param>
+        public void SelectTxt(string value)
+        {
+            this.Click(); // First click to expand the ComboBox
+            Thread.Sleep(100); // Wait for the dropdown to appear
+            this.Find<Element>(value).Click(); // Find and click the text item using basic Element type
+        }
     }
 }

src/common/UITestAutomation/Element/RadioButton.cs

@@ -0,0 +1,38 @@
+// 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.
+
+namespace Microsoft.PowerToys.UITest
+{
+    /// <summary>
+    /// Represents a radio button UI element in the application.
+    /// </summary>
+    public class RadioButton : Element
+    {
+        private static readonly string ExpectedControlType = "ControlType.RadioButton";
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RadioButton"/> class.
+        /// </summary>
+        public RadioButton()
+        {
+            this.TargetControlType = RadioButton.ExpectedControlType;
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the RadioButton is selected.
+        /// </summary>
+        public bool IsSelected => this.Selected;
+
+        /// <summary>
+        /// Select the RadioButton.
+        /// </summary>
+        public void Select()
+        {
+            if (!this.IsSelected)
+            {
+                this.Click();
+            }
+        }
+    }
+}

src/modules/AdvancedPaste/UITest-AdvancedPaste/AdvancedPaste-UITests.csproj

@@ -0,0 +1,38 @@
+<Project Sdk="Microsoft.NET.Sdk">
+	<!-- Look at Directory.Build.props in root for common stuff as well -->
+	<Import Project="..\..\..\Common.Dotnet.CsWinRT.props" />
+
+	<PropertyGroup>
+		<ProjectGuid>{2B1505FA-132A-460B-B22B-7CC3FFAB0C5D}</ProjectGuid>
+		<RootNamespace>Microsoft.AdvancedPaste.UITests</RootNamespace>
+		<IsPackable>false</IsPackable>
+		<Nullable>enable</Nullable>
+		<OutputType>Library</OutputType>
+
+		<!-- This is a UI test, so don't run as part of MSBuild -->
+		<RunVSTest>false</RunVSTest>
+	</PropertyGroup>
+
+	<PropertyGroup>
+		<OutputPath>..\..\..\..\$(Platform)\$(Configuration)\tests\UITests-AdvancedPaste\</OutputPath>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="Appium.WebDriver" />
+		<PackageReference Include="MSTest" />
+		<PackageReference Include="System.Net.Http" />
+		<PackageReference Include="System.Private.Uri" />
+		<PackageReference Include="System.Text.RegularExpressions" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<ProjectReference Include="..\..\..\common\UITestAutomation\UITestAutomation.csproj" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<Content Include="TestFiles\**\*.*">
+			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+		</Content>
+	</ItemGroup>
+
+</Project>

src/modules/AdvancedPaste/UITest-AdvancedPaste/AdvancedPasteUITest.cs

@@ -0,0 +1,787 @@
+// 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.Diagnostics;
+using System.Drawing;
+using System.Globalization;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Windows.Forms;
+
+using Microsoft.AdvancedPaste.UITests.Helper;
+using Microsoft.CodeCoverage.Core.Reports.Coverage;
+using Microsoft.PowerToys.UITest;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using OpenQA.Selenium;
+using Windows.ApplicationModel.DataTransfer;
+using static System.Net.Mime.MediaTypeNames;
+using static System.Resources.ResXFileRef;
+using static System.Runtime.InteropServices.JavaScript.JSType;
+using static System.Windows.Forms.VisualStyles.VisualStyleElement.ToolTip;
+
+namespace Microsoft.AdvancedPaste.UITests
+{
+    [TestClass]
+    public class AdvancedPasteUITest : UITestBase
+    {
+        private readonly string testFilesFolderPath;
+        private readonly string tempRTFFileName = "TempFile.rtf";
+        private readonly string pasteAsPlainTextRawFileName = "PasteAsPlainTextFileRaw.rtf";
+        private readonly string pasteAsPlainTextPlainFileName = "PasteAsPlainTextFilePlain.rtf";
+        private readonly string pasteAsPlainTextPlainNoRepeatFileName = "PasteAsPlainTextFilePlainNoRepeat.rtf";
+        private readonly string wordpadPath = @"C:\Program Files\wordpad\wordpad.exe";
+
+        private readonly string tempTxtFileName = "TempFile.txt";
+        private readonly string pasteAsMarkdownSrcFile = "PasteAsMarkdownFile.html";
+        private readonly string pasteAsMarkdownResultFile = "PasteAsMarkdownResultFile.txt";
+
+        private readonly string pasteAsJsonFileName = "PasteAsJsonFile.xml";
+        private readonly string pasteAsJsonResultFile = "PasteAsJsonResultFile.txt";
+
+        private bool _notepadSettingsChanged;
+
+        // Static constructor - runs before any instance is created
+        static AdvancedPasteUITest()
+        {
+            // Using the predefined settings.
+            // paste as plain text: win + ctrl + alt + o
+            // paste as markdown text: win + ctrl + alt + m
+            // paste as json text: win + ctrl + alt + j
+            CopySettingsFileBeforeTests();
+        }
+
+        public AdvancedPasteUITest()
+            : base(PowerToysModule.PowerToysSettings, size: WindowSize.Small)
+        {
+            Type currentTestType = typeof(AdvancedPasteUITest);
+            string? dirName = Path.GetDirectoryName(currentTestType.Assembly.Location);
+            Assert.IsNotNull(dirName, "Failed to get directory name of the current test assembly.");
+
+            string testFilesFolder = Path.Combine(dirName, "TestFiles");
+            Assert.IsTrue(Directory.Exists(testFilesFolder), $"Test files directory not found at: {testFilesFolder}");
+
+            testFilesFolderPath = testFilesFolder;
+
+            // ignore the notepad settings in pipeline
+            _notepadSettingsChanged = true;
+        }
+
+        [TestInitialize]
+        public void TestInitialize()
+        {
+            Session.CloseMainWindow();
+            SendKeys(Key.Win, Key.M);
+        }
+
+        [TestMethod]
+        [TestCategory("AdvancedPasteUITest")]
+        [TestCategory("PasteAsPlainText")]
+        public void TestCasePasteAsPlainText()
+        {
+            // Copy some rich text(e.g word of the text is different color, another work is bold, underlined, etd.).
+            // Paste the text using standard Windows Ctrl + V shortcut and ensure that rich text is pasted(with all colors, formatting, etc.)
+            DeleteAndCopyFile(pasteAsPlainTextRawFileName, tempRTFFileName);
+            ContentCopyAndPasteDirectly(tempRTFFileName, isRTF: true);
+
+            var resultWithFormatting = FileReader.CompareRtfFiles(
+                Path.Combine(testFilesFolderPath, tempRTFFileName),
+                Path.Combine(testFilesFolderPath, pasteAsPlainTextRawFileName),
+                compareFormatting: true);
+
+            Assert.IsTrue(resultWithFormatting.IsConsistent, "RTF files should be identical including formatting");
+
+            // Paste the text using Paste As Plain Text activation shortcut and ensure that plain text without any formatting is pasted.
+            // Paste again the text using standard Windows Ctrl + V shortcut and ensure the text is now pasted plain without formatting as well.
+            DeleteAndCopyFile(pasteAsPlainTextRawFileName, tempRTFFileName);
+            ContentCopyAndPasteWithShortcutThenPasteAgain(tempRTFFileName, isRTF: true);
+            resultWithFormatting = FileReader.CompareRtfFiles(
+                Path.Combine(testFilesFolderPath, tempRTFFileName),
+                Path.Combine(testFilesFolderPath, pasteAsPlainTextPlainFileName),
+                compareFormatting: true);
+            Assert.IsTrue(resultWithFormatting.IsConsistent, "RTF files should be identical without formatting");
+
+            // Copy some rich text again.
+            // Open Advanced Paste window using hotkey, click Paste as Plain Text button and confirm that plain text without any formatting is pasted.
+            DeleteAndCopyFile(pasteAsPlainTextRawFileName, tempRTFFileName);
+            ContentCopyAndPasteCase3(tempRTFFileName, isRTF: true);
+            resultWithFormatting = FileReader.CompareRtfFiles(
+                Path.Combine(testFilesFolderPath, tempRTFFileName),
+                Path.Combine(testFilesFolderPath, pasteAsPlainTextPlainNoRepeatFileName),
+                compareFormatting: true);
+            Assert.IsTrue(resultWithFormatting.IsConsistent, "RTF files should be identical without formatting");
+
+            // Copy some rich text again.
+            // Open Advanced Paste window using hotkey, press Ctrl + 1 and confirm that plain text without any formatting is pasted.
+            DeleteAndCopyFile(pasteAsPlainTextRawFileName, tempRTFFileName);
+            ContentCopyAndPasteCase4(tempRTFFileName, isRTF: true);
+            resultWithFormatting = FileReader.CompareRtfFiles(
+                Path.Combine(testFilesFolderPath, tempRTFFileName),
+                Path.Combine(testFilesFolderPath, pasteAsPlainTextPlainNoRepeatFileName),
+                compareFormatting: true);
+            Assert.IsTrue(resultWithFormatting.IsConsistent, "RTF files should be identical without formatting");
+        }
+
+        [TestMethod]
+        [TestCategory("AdvancedPasteUITest")]
+        [TestCategory("PasteAsMarkdown")]
+        public void TestCasePasteAsMarkdown()
+        {
+            if (_notepadSettingsChanged == false)
+            {
+                ChangeNotePadSettings();
+            }
+
+            // TODO: Open Settings and set Paste as Markdown directly hotkey
+
+            // Copy some text(e.g.some HTML text - convertible to Markdown)
+            // Paste the text using set hotkey and confirm that pasted text is converted to markdown
+            DeleteAndCopyFile(pasteAsMarkdownSrcFile, tempTxtFileName);
+            ContentCopyAndPasteAsMarkdownCase1(tempTxtFileName);
+            var result = FileReader.CompareRtfFiles(
+                Path.Combine(testFilesFolderPath, tempTxtFileName),
+                Path.Combine(testFilesFolderPath, pasteAsMarkdownResultFile),
+                compareFormatting: true);
+            Assert.IsTrue(result.IsConsistent, "Paste as markdown using shortcut failed.");
+
+            // Copy some text(same as in the previous step or different.If nothing is coppied between steps, previously pasted Markdown text will be picked up from clipboard and converted again to nested Markdown).
+            // Open Advanced Paste window using hotkey, click Paste as markdown button and confirm that pasted text is converted to markdown
+            DeleteAndCopyFile(pasteAsMarkdownSrcFile, tempTxtFileName);
+            ContentCopyAndPasteAsMarkdownCase2(tempTxtFileName);
+            result = FileReader.CompareRtfFiles(
+                Path.Combine(testFilesFolderPath, tempTxtFileName),
+                Path.Combine(testFilesFolderPath, pasteAsMarkdownResultFile),
+                compareFormatting: true);
+            Assert.IsTrue(result.IsConsistent, "Paste as markdown using shortcut failed.");
+
+            // Copy some text(same as in the previous step or different.If nothing is coppied between steps, previously pasted Markdown text will be picked up from clipboard and converted again to nested Markdown).
+            // Open Advanced Paste window using hotkey, press Ctrl + 2 and confirm that pasted text is converted to markdown
+            DeleteAndCopyFile(pasteAsMarkdownSrcFile, tempTxtFileName);
+            ContentCopyAndPasteAsMarkdownCase3(tempTxtFileName);
+            result = FileReader.CompareRtfFiles(
+                Path.Combine(testFilesFolderPath, tempTxtFileName),
+                Path.Combine(testFilesFolderPath, pasteAsMarkdownResultFile),
+                compareFormatting: true);
+            Assert.IsTrue(result.IsConsistent, "Paste as markdown using shortcut failed.");
+        }
+
+        [TestMethod]
+        [TestCategory("AdvancedPasteUITest")]
+        [TestCategory("PasteAsJSON")]
+        public void TestCasePasteAsJSON()
+        {
+            if (_notepadSettingsChanged == false)
+            {
+                ChangeNotePadSettings();
+            }
+
+            // TODO: Open Settings and set Paste as JSON directly hotkey
+
+            // Copy some XML or CSV text(or any other text, it will be converted to simple JSON object)
+            // Paste the text using set hotkey and confirm that pasted text is converted to JSON
+            DeleteAndCopyFile(pasteAsJsonFileName, tempTxtFileName);
+            ContentCopyAndPasteAsJsonCase1(tempTxtFileName);
+            var result = FileReader.CompareRtfFiles(
+                Path.Combine(testFilesFolderPath, tempTxtFileName),
+                Path.Combine(testFilesFolderPath, pasteAsJsonResultFile),
+                compareFormatting: true);
+            Assert.IsTrue(result.IsConsistent, "Paste as Json using shortcut failed.");
+
+            // Copy some text(same as in the previous step or different.If nothing is coppied between steps, previously pasted JSON text will be picked up from clipboard and converted again to nested JSON).
+            // Open Advanced Paste window using hotkey, click Paste as markdown button and confirm that pasted text is converted to markdown
+            DeleteAndCopyFile(pasteAsJsonFileName, tempTxtFileName);
+            ContentCopyAndPasteAsJsonCase2(tempTxtFileName);
+            result = FileReader.CompareRtfFiles(
+                Path.Combine(testFilesFolderPath, tempTxtFileName),
+                Path.Combine(testFilesFolderPath, pasteAsJsonResultFile),
+                compareFormatting: true);
+            Assert.IsTrue(result.IsConsistent, "Paste as Json using shortcut failed.");
+
+            // Copy some text(same as in the previous step or different.If nothing is coppied between steps, previously pasted JSON text will be picked up from clipboard and converted again to nested JSON).
+            // Open Advanced Paste window using hotkey, press Ctrl + 3 and confirm that pasted text is converted to markdown
+            DeleteAndCopyFile(pasteAsJsonFileName, tempTxtFileName);
+            ContentCopyAndPasteAsJsonCase3(tempTxtFileName);
+            result = FileReader.CompareRtfFiles(
+                Path.Combine(testFilesFolderPath, tempTxtFileName),
+                Path.Combine(testFilesFolderPath, pasteAsJsonResultFile),
+                compareFormatting: true);
+            Assert.IsTrue(result.IsConsistent, "Paste as Json using shortcut failed.");
+        }
+
+        /*
+         * Clipboard History
+           - [] Open Settings and Enable clipboard history (if not enabled already). Open Advanced Paste window with hotkey, click Clipboard history and try deleting some entry. Check OS clipboard history (Win+V), and confirm that the same entry no longer exist.
+           - [] Open Advanced Paste window with hotkey, click Clipboard history, and click any entry (but first). Observe that entry is put on top of clipboard history. Check OS clipboard history (Win+V), and confirm that the same entry is on top of the clipboard.
+           - [] Open Settings and Disable clipboard history. Open Advanced Paste window with hotkey and observe that Clipboard history button is disabled.
+         * Disable Advanced Paste, try different Advanced Paste hotkeys and confirm that it's disabled and nothing happens.
+         */
+        private void TestCaseClipboardHistory()
+        {
+        }
+
+        private void ContentCopyAndPasteDirectly(string fileName, bool isRTF = false)
+        {
+            string tempFile = Path.Combine(testFilesFolderPath, fileName);
+
+            Process process = Process.Start(isRTF ? wordpadPath : "notepad.exe", tempFile);
+            if (process == null)
+            {
+                throw new InvalidOperationException($"Failed to start {(isRTF ? "WordPad" : "Notepad")}.");
+            }
+
+            string windowTitle = Path.GetFileNameWithoutExtension(tempFile) + (isRTF ? " - WordPad" : " - Notepad");
+
+            Thread.Sleep(15000);
+
+            // Replace SetForegroundWindow with the improved function
+            var window = this.Find<Window>(windowTitle, global: true);
+
+            if (window == null)
+            {
+                throw new InvalidOperationException($"Failed to set focus to {(isRTF ? "WordPad" : "Notepad")} window.");
+            }
+
+            window.Click();
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.A);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.C);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Delete);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.V);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Backspace);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.S);
+            Thread.Sleep(1000);
+
+            process.Kill(true);
+        }
+
+        private void ContentCopyAndPasteWithShortcutThenPasteAgain(string fileName, bool isRTF = false)
+        {
+            string tempFile = Path.Combine(testFilesFolderPath, fileName);
+
+            Process process = Process.Start(isRTF ? wordpadPath : "notepad.exe", tempFile);
+            if (process == null)
+            {
+                throw new InvalidOperationException($"Failed to start {(isRTF ? "WordPad" : "Notepad")}.");
+            }
+
+            string windowTitle = Path.GetFileNameWithoutExtension(tempFile) + (isRTF ? " - WordPad" : " - Notepad");
+
+            Thread.Sleep(15000);
+
+            // Replace SetForegroundWindow with the improved function
+            var window = this.Find<Window>(windowTitle, global: true);
+
+            if (window == null)
+            {
+                throw new InvalidOperationException($"Failed to set focus to {(isRTF ? "WordPad" : "Notepad")} window.");
+            }
+
+            window.Click();
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.A);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.C);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Delete);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Win, Key.LCtrl, Key.Alt, Key.O);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.V);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.S);
+            Thread.Sleep(1000);
+
+            process.Kill(true);
+        }
+
+        private void ContentCopyAndPasteCase3(string fileName, bool isRTF = false)
+        {
+            // Copy some rich text again.
+            // Open Advanced Paste window using hotkey, click Paste as Plain Text button and confirm that plain text without any formatting is pasted.
+            string tempFile = Path.Combine(testFilesFolderPath, fileName);
+
+            Process process = Process.Start(isRTF ? wordpadPath : "notepad.exe", tempFile);
+            if (process == null)
+            {
+                throw new InvalidOperationException($"Failed to start {(isRTF ? "WordPad" : "Notepad")}.");
+            }
+
+            string windowTitle = Path.GetFileNameWithoutExtension(tempFile) + (isRTF ? " - WordPad" : " - Notepad");
+
+            Thread.Sleep(15000);
+
+            // Replace SetForegroundWindow with the improved function
+            var window = this.Find<Window>(windowTitle, global: true);
+
+            if (window == null)
+            {
+                throw new InvalidOperationException($"Failed to set focus to {(isRTF ? "WordPad" : "Notepad")} window.");
+            }
+
+            window.Click();
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.A);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.C);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Delete);
+            Thread.Sleep(1000);
+
+            // Open Advanced Paste window using hotkey
+            this.SendKeys(Key.Win, Key.Shift, Key.V);
+            Thread.Sleep(15000);
+
+            // Click Paste as Plain Text button and confirm that plain text without any formatting is pasted.
+            var apWind = this.Find<Window>("Advanced Paste", global: true);
+            apWind.Find<TextBlock>("Paste as plain text").Click();
+
+            this.SendKeys(Key.LCtrl, Key.S);
+            Thread.Sleep(1000);
+
+            process.Kill(true);
+        }
+
+        private void ContentCopyAndPasteCase4(string fileName, bool isRTF = false)
+        {
+            // Copy some rich text again.
+            // Open Advanced Paste window using hotkey, press Ctrl + 1 and confirm that plain text without any formatting is pasted.
+            string tempFile = Path.Combine(testFilesFolderPath, fileName);
+
+            Process process = Process.Start(isRTF ? wordpadPath : "notepad.exe", tempFile);
+            if (process == null)
+            {
+                throw new InvalidOperationException($"Failed to start {(isRTF ? "WordPad" : "Notepad")}.");
+            }
+
+            string windowTitle = Path.GetFileNameWithoutExtension(tempFile) + (isRTF ? " - WordPad" : " - Notepad");
+
+            Thread.Sleep(15000);
+
+            // Replace SetForegroundWindow with the improved function
+            var window = this.Find<Window>(windowTitle, global: true);
+
+            if (window == null)
+            {
+                throw new InvalidOperationException($"Failed to set focus to {(isRTF ? "WordPad" : "Notepad")} window.");
+            }
+
+            window.Click();
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.A);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.C);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Delete);
+            Thread.Sleep(1000);
+
+            // Open Advanced Paste window using hotkey
+            this.SendKeys(Key.Win, Key.Shift, Key.V);
+            Thread.Sleep(1000);
+
+            // press Ctrl + 1 and confirm that plain text without any formatting is pasted.
+            this.SendKeys(Key.LCtrl, Key.Num1);
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.S);
+            Thread.Sleep(1000);
+
+            process.Kill(true);
+        }
+
+        private void ContentCopyAndPasteAsMarkdownCase1(string fileName, bool isRTF = false)
+        {
+            // Copy some rich text again.
+            // Open Advanced Paste window using hotkey, press Ctrl + 1 and confirm that plain text without any formatting is pasted.
+            string tempFile = Path.Combine(testFilesFolderPath, fileName);
+
+            Process process = Process.Start(isRTF ? wordpadPath : "notepad.exe", tempFile);
+            if (process == null)
+            {
+                throw new InvalidOperationException($"Failed to start {(isRTF ? "WordPad" : "Notepad")}.");
+            }
+
+            string windowTitle = Path.GetFileNameWithoutExtension(tempFile) + (isRTF ? " - WordPad" : " - Notepad");
+
+            Thread.Sleep(15000);
+
+            // Replace SetForegroundWindow with the improved function
+            var window = this.Find<Window>(windowTitle, global: true);
+
+            if (window == null)
+            {
+                throw new InvalidOperationException($"Failed to set focus to {(isRTF ? "WordPad" : "Notepad")} window.");
+            }
+
+            window.Click();
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.A);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.C);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Delete);
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.Win, Key.LCtrl, Key.Alt, Key.M);
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.S);
+            Thread.Sleep(1000);
+
+            window.Close();
+        }
+
+        private void ContentCopyAndPasteAsMarkdownCase2(string fileName, bool isRTF = false)
+        {
+            string tempFile = Path.Combine(testFilesFolderPath, fileName);
+
+            Process process = Process.Start(isRTF ? wordpadPath : "notepad.exe", tempFile);
+            if (process == null)
+            {
+                throw new InvalidOperationException($"Failed to start {(isRTF ? "WordPad" : "Notepad")}.");
+            }
+
+            string windowTitle = Path.GetFileNameWithoutExtension(tempFile) + (isRTF ? " - WordPad" : " - Notepad");
+
+            Thread.Sleep(15000);
+
+            // Replace SetForegroundWindow with the improved function
+            var window = this.Find<Window>(windowTitle, global: true);
+
+            if (window == null)
+            {
+                throw new InvalidOperationException($"Failed to set focus to {(isRTF ? "WordPad" : "Notepad")} window.");
+            }
+
+            window.Click();
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.A);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.C);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Delete);
+            Thread.Sleep(1000);
+
+            // Open Advanced Paste window using hotkey
+            this.SendKeys(Key.Win, Key.Shift, Key.V);
+            Thread.Sleep(15000);
+
+            // click Paste as markdown button and confirm that pasted text is converted to markdown
+            var apWind = this.Find<Window>("Advanced Paste", global: true);
+            apWind.Find<TextBlock>("Paste as markdown").Click();
+
+            this.SendKeys(Key.LCtrl, Key.S);
+            Thread.Sleep(1000);
+
+            window.Close();
+        }
+
+        private void ContentCopyAndPasteAsMarkdownCase3(string fileName, bool isRTF = false)
+        {
+            string tempFile = Path.Combine(testFilesFolderPath, fileName);
+
+            Process process = Process.Start(isRTF ? wordpadPath : "notepad.exe", tempFile);
+            if (process == null)
+            {
+                throw new InvalidOperationException($"Failed to start {(isRTF ? "WordPad" : "Notepad")}.");
+            }
+
+            string windowTitle = Path.GetFileNameWithoutExtension(tempFile) + (isRTF ? " - WordPad" : " - Notepad");
+
+            Thread.Sleep(15000);
+
+            // Replace SetForegroundWindow with the improved function
+            var window = this.Find<Window>(windowTitle, global: true);
+
+            if (window == null)
+            {
+                throw new InvalidOperationException($"Failed to set focus to {(isRTF ? "WordPad" : "Notepad")} window.");
+            }
+
+            window.Click();
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.A);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.C);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Delete);
+            Thread.Sleep(1000);
+
+            // Open Advanced Paste window using hotkey
+            this.SendKeys(Key.Win, Key.Shift, Key.V);
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.Num2);
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.S);
+            Thread.Sleep(1000);
+
+            window.Close();
+        }
+
+        private void ContentCopyAndPasteAsJsonCase1(string fileName, bool isRTF = false)
+        {
+            // Copy some rich text again.
+            // Open Advanced Paste window using hotkey, press Ctrl + 1 and confirm that plain text without any formatting is pasted.
+            string tempFile = Path.Combine(testFilesFolderPath, fileName);
+
+            Process process = Process.Start(isRTF ? wordpadPath : "notepad.exe", tempFile);
+            if (process == null)
+            {
+                throw new InvalidOperationException($"Failed to start {(isRTF ? "WordPad" : "Notepad")}.");
+            }
+
+            string windowTitle = Path.GetFileNameWithoutExtension(tempFile) + (isRTF ? " - WordPad" : " - Notepad");
+
+            Thread.Sleep(15000);
+
+            // Replace SetForegroundWindow with the improved function
+            var window = this.Find<Window>(windowTitle, global: true);
+
+            if (window == null)
+            {
+                throw new InvalidOperationException($"Failed to set focus to {(isRTF ? "WordPad" : "Notepad")} window.");
+            }
+
+            window.Click();
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.A);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.C);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Delete);
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.Win, Key.LCtrl, Key.Alt, Key.J);
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.S);
+            Thread.Sleep(1000);
+
+            window.Close();
+        }
+
+        private void ContentCopyAndPasteAsJsonCase2(string fileName, bool isRTF = false)
+        {
+            string tempFile = Path.Combine(testFilesFolderPath, fileName);
+
+            Process process = Process.Start(isRTF ? wordpadPath : "notepad.exe", tempFile);
+            if (process == null)
+            {
+                throw new InvalidOperationException($"Failed to start {(isRTF ? "WordPad" : "Notepad")}.");
+            }
+
+            string windowTitle = Path.GetFileNameWithoutExtension(tempFile) + (isRTF ? " - WordPad" : " - Notepad");
+
+            Thread.Sleep(15000);
+
+            // Replace SetForegroundWindow with the improved function
+            var window = this.Find<Window>(windowTitle, global: true);
+
+            if (window == null)
+            {
+                throw new InvalidOperationException($"Failed to set focus to {(isRTF ? "WordPad" : "Notepad")} window.");
+            }
+
+            window.Click();
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.A);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.C);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Delete);
+            Thread.Sleep(1000);
+
+            // Open Advanced Paste window using hotkey
+            this.SendKeys(Key.Win, Key.Shift, Key.V);
+            Thread.Sleep(15000);
+
+            // click Paste as markdown button and confirm that pasted text is converted to markdown
+            var apWind = this.Find<Window>("Advanced Paste", global: true);
+            apWind.Find<TextBlock>("Paste as JSON").Click();
+
+            this.SendKeys(Key.LCtrl, Key.S);
+            Thread.Sleep(1000);
+
+            window.Close();
+        }
+
+        private void ContentCopyAndPasteAsJsonCase3(string fileName, bool isRTF = false)
+        {
+            string tempFile = Path.Combine(testFilesFolderPath, fileName);
+
+            Process process = Process.Start(isRTF ? wordpadPath : "notepad.exe", tempFile);
+            if (process == null)
+            {
+                throw new InvalidOperationException($"Failed to start {(isRTF ? "WordPad" : "Notepad")}.");
+            }
+
+            string windowTitle = Path.GetFileNameWithoutExtension(tempFile) + (isRTF ? " - WordPad" : " - Notepad");
+
+            Thread.Sleep(15000);
+
+            // Replace SetForegroundWindow with the improved function
+            var window = this.Find<Window>(windowTitle, global: true);
+
+            if (window == null)
+            {
+                throw new InvalidOperationException($"Failed to set focus to {(isRTF ? "WordPad" : "Notepad")} window.");
+            }
+
+            window.Click();
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.A);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.LCtrl, Key.C);
+            Thread.Sleep(1000);
+            this.SendKeys(Key.Delete);
+            Thread.Sleep(1000);
+
+            // Open Advanced Paste window using hotkey
+            this.SendKeys(Key.Win, Key.Shift, Key.V);
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.Num3);
+            Thread.Sleep(1000);
+
+            this.SendKeys(Key.LCtrl, Key.S);
+            Thread.Sleep(1000);
+
+            window.Close();
+        }
+
+        private string DeleteAndCopyFile(string sourceFileName, string destinationFileName)
+        {
+            string sourcePath = Path.Combine(testFilesFolderPath, sourceFileName);
+            string destinationPath = Path.Combine(testFilesFolderPath, destinationFileName);
+
+            // Check if source file exists
+            if (!File.Exists(sourcePath))
+            {
+                throw new FileNotFoundException($"Source file not found: {sourcePath}");
+            }
+
+            // Delete destination file if it exists
+            if (File.Exists(destinationPath))
+            {
+                try
+                {
+                    File.Delete(destinationPath);
+                }
+                catch (IOException ex)
+                {
+                    throw new IOException($"Failed to delete file {destinationPath}. The file may be in use: {ex.Message}", ex);
+                }
+            }
+
+            // Copy the source file to the destination
+            try
+            {
+                File.Copy(sourcePath, destinationPath);
+            }
+            catch (IOException ex)
+            {
+                throw new IOException($"Failed to copy file from {sourcePath} to {destinationPath}: {ex.Message}", ex);
+            }
+
+            return destinationPath;
+        }
+
+        private void ChangeNotePadSettings()
+        {
+            Process process = Process.Start("notepad.exe");
+            if (process == null)
+            {
+                throw new InvalidOperationException($"Failed to start Notepad.exe");
+            }
+
+            Thread.Sleep(15000);
+
+            var window = this.Find<Window>("Untitled - Notepad", global: true);
+            window.Find<PowerToys.UITest.Button>("Settings").Click();
+            var combobox = window.Find<PowerToys.UITest.ComboBox>("Opening files");
+            combobox.SelectTxt("Open in a new window");
+
+            window.Find<Group>("When Notepad starts").Click();
+
+            window.Find<PowerToys.UITest.RadioButton>("Open a new window").Select();
+
+            _notepadSettingsChanged = true;
+            window.Close();
+        }
+
+        private static void CopySettingsFileBeforeTests()
+        {
+            try
+            {
+                // Determine the assembly location and test files path
+                string? assemblyLocation = Path.GetDirectoryName(typeof(AdvancedPasteUITest).Assembly.Location);
+                if (assemblyLocation == null)
+                {
+                    Debug.WriteLine("ERROR: Failed to get assembly location");
+                    return;
+                }
+
+                string testFilesFolder = Path.Combine(assemblyLocation, "TestFiles");
+                if (!Directory.Exists(testFilesFolder))
+                {
+                    Debug.WriteLine($"ERROR: Test files directory not found at: {testFilesFolder}");
+                    return;
+                }
+
+                // Settings file source path
+                string settingsFileName = "settings.json";
+                string sourceSettingsPath = Path.Combine(testFilesFolder, settingsFileName);
+
+                // Make sure the source file exists
+                if (!File.Exists(sourceSettingsPath))
+                {
+                    Debug.WriteLine($"ERROR: Settings file not found at: {sourceSettingsPath}");
+                    return;
+                }
+
+                // Determine the target directory in %LOCALAPPDATA%
+                string targetDirectory = Path.Combine(
+                    Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+                    "Microsoft",
+                    "PowerToys",
+                    "AdvancedPaste");
+
+                // Create the directory if it doesn't exist
+                if (!Directory.Exists(targetDirectory))
+                {
+                    Directory.CreateDirectory(targetDirectory);
+                }
+
+                string targetSettingsPath = Path.Combine(targetDirectory, settingsFileName);
+
+                // Copy the file and overwrite if it exists
+                File.Copy(sourceSettingsPath, targetSettingsPath, true);
+
+                Debug.WriteLine($"Successfully copied settings file from {sourceSettingsPath} to {targetSettingsPath}");
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine($"ERROR copying settings file: {ex.Message}");
+            }
+        }
+    }
+}

src/modules/AdvancedPaste/UITest-AdvancedPaste/Helper/FileReader.cs

@@ -0,0 +1,85 @@
+// 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.IO;
+using System.Text;
+using System.Windows.Forms;
+
+namespace Microsoft.AdvancedPaste.UITests.Helper;
+
+public class FileReader
+{
+    public static string ReadContent(string filePath)
+    {
+        try
+        {
+            return File.ReadAllText(filePath);
+        }
+        catch (Exception ex)
+        {
+            throw new InvalidOperationException($"Failed to read file: {ex.Message}", ex);
+        }
+    }
+
+    public static string ReadRTFPlainText(string filePath)
+    {
+        try
+        {
+            using (var rtb = new System.Windows.Forms.RichTextBox())
+            {
+                rtb.Rtf = File.ReadAllText(filePath);
+                return rtb.Text;
+            }
+        }
+        catch (Exception ex)
+        {
+            throw new InvalidOperationException($"Failed to read plain text from file: {ex.Message}", ex);
+        }
+    }
+
+    /// <summary>
+    /// Compares the contents of two RTF files to check if they are consistent.
+    /// </summary>
+    /// <param name="firstFilePath">Path to the first RTF file</param>
+    /// <param name="secondFilePath">Path to the second RTF file</param>
+    /// <param name="compareFormatting">If true, compares the raw RTF content (including formatting).
+    /// If false, compares only the plain text content.</param>
+    /// <returns>
+    /// A tuple containing: (bool isConsistent, string firstContent, string secondContent)
+    /// - isConsistent: true if the files are consistent according to the comparison method
+    /// - firstContent: the content of the first file
+    /// - secondContent: the content of the second file
+    /// </returns>
+    public static (bool IsConsistent, string FirstContent, string SecondContent) CompareRtfFiles(
+        string firstFilePath,
+        string secondFilePath,
+        bool compareFormatting = false)
+    {
+        try
+        {
+            string firstContent, secondContent;
+
+            if (compareFormatting)
+            {
+                // Compare raw RTF content (including formatting)
+                firstContent = ReadContent(firstFilePath);
+                secondContent = ReadContent(secondFilePath);
+            }
+            else
+            {
+                // Compare only the plain text content
+                firstContent = ReadRTFPlainText(firstFilePath);
+                secondContent = ReadRTFPlainText(secondFilePath);
+            }
+
+            bool isConsistent = string.Equals(firstContent, secondContent, StringComparison.Ordinal);
+            return (isConsistent, firstContent, secondContent);
+        }
+        catch (Exception ex)
+        {
+            throw new InvalidOperationException($"Failed to compare RTF files: {ex.Message}", ex);
+        }
+    }
+}

src/modules/AdvancedPaste/UITest-AdvancedPaste/TestFiles/PasteAsJsonFile.xml

@@ -0,0 +1,6 @@
+<note>
+    <to>Tove</to>
+    <from>Jani</from>
+    <heading>Reminder</heading>
+    <body>Don't forget me this weekend!</body>
+</note>

src/modules/AdvancedPaste/UITest-AdvancedPaste/TestFiles/PasteAsJsonResultFile.txt

@@ -0,0 +1,8 @@
+{
+  "note": {
+    "to": "Tove",
+    "from": "Jani",
+    "heading": "Reminder",
+    "body": "Don't forget me this weekend!"
+  }
+}

src/modules/AdvancedPaste/UITest-AdvancedPaste/TestFiles/PasteAsMarkdownFile.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+
+<body>
+
+    <h2 title="I'm a header">The title Attribute</h2>
+
+    <p title="I'm a tooltip">Mouse over this paragraph, to display the title attribute as a tooltip.</p>
+
+</body>
+
+</html>

src/modules/AdvancedPaste/UITest-AdvancedPaste/TestFiles/PasteAsMarkdownResultFile.txt

@@ -0,0 +1,3 @@
+## The title Attribute
+ 
+Mouse over this paragraph, to display the title attribute as a tooltip.

src/modules/AdvancedPaste/UITest-AdvancedPaste/TestFiles/settings.json

@@ -0,0 +1 @@
+{"properties":{"IsAdvancedAIEnabled":{"value":false},"ShowCustomPreview":{"value":true},"CloseAfterLosingFocus":{"value":false},"advanced-paste-ui-hotkey":{"win":true,"ctrl":false,"alt":false,"shift":true,"code":86,"key":""},"paste-as-plain-hotkey":{"win":true,"ctrl":true,"alt":true,"shift":false,"code":79,"key":""},"paste-as-markdown-hotkey":{"win":true,"ctrl":true,"alt":true,"shift":false,"code":77,"key":""},"paste-as-json-hotkey":{"win":true,"ctrl":true,"alt":true,"shift":false,"code":74,"key":""},"custom-actions":{"value":[]},"additional-actions":{"image-to-text":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true},"paste-as-file":{"isShown":true,"paste-as-txt-file":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true},"paste-as-png-file":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true},"paste-as-html-file":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true}},"transcode":{"isShown":true,"transcode-to-mp3":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true},"transcode-to-mp4":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true}}}},"name":"AdvancedPaste","version":"1"}

src/modules/AdvancedPaste/UITest-AdvancedPaste/UITestAdvancedPaste.md

@@ -0,0 +1,41 @@
+## [Advanced Paste](tests-checklist-template-advanced-paste-section.md)
+  NOTES:
+    When using Advanced Paste, make sure that window focused while starting/using Advanced paste is text editor or has text input field focused (e.g. Word).
+ * Paste As Plain Text
+   - [x] Copy some rich text (e.g word of the text is different color, another work is bold, underlined, etd.).
+   - [x] Paste the text using standard Windows Ctrl + V shortcut and ensure that rich text is pasted (with all colors, formatting, etc.)
+   - [x] Paste the text using Paste As Plain Text activation shortcut and ensure that plain text without any formatting is pasted.
+   - [x] Paste again the text using standard Windows Ctrl + V shortcut and ensure the text is now pasted plain without formatting as well.
+   - [x] Copy some rich text again.
+   - [x] Open Advanced Paste window using hotkey, click Paste as Plain Text button and confirm that plain text without any formatting is pasted.
+   - [x] Copy some rich text again.
+   - [x] Open Advanced Paste window using hotkey, press Ctrl + 1 and confirm that plain text without any formatting is pasted.
+ * Paste As Markdown
+   - [] Open Settings and set Paste as Markdown directly hotkey
+   - [x] Copy some text (e.g. some HTML text - convertible to Markdown)
+   - [x] Paste the text using set hotkey and confirm that pasted text is converted to markdown
+   - [x] Copy some text (same as in the previous step or different. If nothing is coppied between steps, previously pasted Markdown text will be picked up from clipboard and converted again to nested Markdown).
+   - [x] Open Advanced Paste window using hotkey, click Paste as markdown button and confirm that pasted text is converted to markdown
+   - [x] Copy some text (same as in the previous step or different. If nothing is coppied between steps, previously pasted Markdown text will be picked up from clipboard and converted again to nested Markdown).
+   - [x] Open Advanced Paste window using hotkey, press Ctrl + 2 and confirm that pasted text is converted to markdown
+ * Paste As JSON
+   - [] Open Settings and set Paste as JSON directly hotkey
+   - [x] Copy some XML or CSV text (or any other text, it will be converted to simple JSON object)
+   - [x] Paste the text using set hotkey and confirm that pasted text is converted to JSON
+   - [x] Copy some text (same as in the previous step or different. If nothing is coppied between steps, previously pasted JSON text will be picked up from clipboard and converted again to nested JSON).
+   - [x] Open Advanced Paste window using hotkey, click Paste as markdown button and confirm that pasted text is converted to markdown
+   - [x] Copy some text (same as in the previous step or different. If nothing is coppied between steps, previously pasted JSON text will be picked up from clipboard and converted again to nested JSON).
+   - [x] Open Advanced Paste window using hotkey, press Ctrl + 3 and confirm that pasted text is converted to markdown
+ * Paste as custom format using AI
+   - [] Open Settings, navigate to Enable Paste with AI and set OpenAI key.
+   - [] Copy some text to clipboard. Any text.
+   - [] Open Advanced Paste window using hotkey, and confirm that Custom intput text box is now enabled. Write "Insert smiley after every word" and press Enter. Observe that result preview shows coppied text with smileys between words. Press Enter to paste the result and observe that it is pasted.
+   - [] Open Advanced Paste window using hotkey. Input some query (any, feel free to play around) and press Enter. When result is shown, click regenerate button, to see if new result is generated. Select one of the results and paste. Observe that correct result is pasted.
+   - [] Create few custom actions. Set up hotkey for custom actions and confirm they work. Enable/disable custom actions and confirm that the change is reflected in Advanced Paste UI - custom action is not listed. Try different ctrl + <num> in-app shortcuts for custom actions. Try moving custom actions up/down and confirm that the change is reflected in Advanced Paste UI.
+   - [] Open Settings and disable Custom format preview. Open Advanced Paste window with hotkey, enter some query and press enter. Observe that result is now pasted right away, without showing the preview first.
+   - [] Open Settings and Disable Enable Paste with AI. Open Advanced Paste window with hotkey and observe that Custom Input text box is now disabled.
+ * Clipboard History
+   - [] Open Settings and Enable clipboard history (if not enabled already). Open Advanced Paste window with hotkey, click Clipboard history and try deleting some entry. Check OS clipboard history (Win+V), and confirm that the same entry no longer exist.
+   - [] Open Advanced Paste window with hotkey, click Clipboard history, and click any entry (but first). Observe that entry is put on top of clipboard history. Check OS clipboard history (Win+V), and confirm that the same entry is on top of the clipboard.
+   - [] Open Settings and Disable clipboard history. Open Advanced Paste window with hotkey and observe that Clipboard history button is disabled.
+ * Disable Advanced Paste, try different Advanced Paste hotkeys and confirm that it's disabled and nothing happens.

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Registry.UnitTests/BasicStructureTest.cs

@@ -1,18 +0,0 @@
-// 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 Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace Microsoft.CmdPal.Ext.Registry.UnitTests;
-
-[TestClass]
-public class BasicStructureTest
-{
-    [TestMethod]
-    public void CanCreateTestClass()
-    {
-        // This is a basic test to verify the test project structure is correct
-        Assert.IsTrue(true);
-    }
-}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Registry.UnitTests/KeyNameTest.cs

@@ -1,26 +0,0 @@
-// 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 Microsoft.CmdPal.Ext.Registry.Constants;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace Microsoft.CmdPal.Ext.Registry.UnitTests;
-
-[TestClass]
-public class KeyNameTest
-{
-    [TestMethod]
-    [DataRow("HKEY", KeyName.FirstPart)]
-    [DataRow("HKEY_", KeyName.FirstPartUnderscore)]
-    [DataRow("HKCR", KeyName.ClassRootShort)]
-    [DataRow("HKCC", KeyName.CurrentConfigShort)]
-    [DataRow("HKCU", KeyName.CurrentUserShort)]
-    [DataRow("HKLM", KeyName.LocalMachineShort)]
-    [DataRow("HKPD", KeyName.PerformanceDataShort)]
-    [DataRow("HKU", KeyName.UsersShort)]
-    public void TestConstants(string shortName, string baseName)
-    {
-        Assert.AreEqual(shortName, baseName);
-    }
-}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Registry.UnitTests/Microsoft.CmdPal.Ext.Registry.UnitTests.csproj

@@ -1,22 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <!-- Look at Directory.Build.props in root for common stuff as well -->
-  <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
-
-  <PropertyGroup>
-    <IsPackable>false</IsPackable>
-    <IsTestProject>true</IsTestProject>
-    <RootNamespace>Microsoft.CmdPal.Ext.Registry.UnitTests</RootNamespace>
-    <OutputPath>$(SolutionDir)$(Platform)\$(Configuration)\WinUI3Apps\CmdPal\tests\</OutputPath>
-    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
-    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Moq" />
-    <PackageReference Include="MSTest" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\ext\Microsoft.CmdPal.Ext.Registry\Microsoft.CmdPal.Ext.Registry.csproj" />
-  </ItemGroup>
-</Project>

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Registry.UnitTests/QueryHelperTest.cs

@@ -1,52 +0,0 @@
-// 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 Microsoft.CmdPal.Ext.Registry.Helpers;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace Microsoft.CmdPal.Ext.Registry.UnitTests;
-
-[TestClass]
-public class QueryHelperTest
-{
-    [TestMethod]
-    [DataRow(@"HKLM", false, @"HKLM", "")]
-    [DataRow(@"HKLM\", false, @"HKLM\", "")]
-    [DataRow(@"HKLM\\", true, @"HKLM", "")]
-    [DataRow(@"HKLM\\Test", true, @"HKLM", "Test")]
-    [DataRow(@"HKLM\Test\\TestTest", true, @"HKLM\Test", "TestTest")]
-    [DataRow(@"HKLM\Test\\\TestTest", true, @"HKLM\Test", @"\TestTest")]
-    [DataRow("HKLM/\"Software\"/", false, @"HKLM\Software\", "")]
-    [DataRow("HKLM/\"Software\"//test", true, @"HKLM\Software", "test")]
-    [DataRow("HKLM/\"Software\"//test/123", true, @"HKLM\Software", "test/123")]
-    [DataRow("HKLM/\"Software\"//test\\123", true, @"HKLM\Software", @"test\123")]
-    [DataRow("HKLM/\"Software\"/test", false, @"HKLM\Software\test", "")]
-    [DataRow("HKLM\\Software\\\"test\"", false, @"HKLM\Software\test", "")]
-    [DataRow("HKLM\\\"Software\"\\\"test\"", false, @"HKLM\Software\test", "")]
-    [DataRow("HKLM\\\"Software\"\\\"test/software\"", false, @"HKLM\Software\test/software", "")]
-    [DataRow("HKLM\\\"Software\"/\"test\"\\hello", false, @"HKLM\Software\test\hello", "")]
-    [DataRow("HKLM\\\"Software\"\\\"test\"\\hello\\\\\"some/value\"", true, @"HKLM\Software\test\hello", "some/value")]
-    [DataRow("HKLM\\\"Software\"\\\"test\"/hello\\\\\"some/value\"", true, @"HKLM\Software\test\hello", "some/value")]
-    [DataRow("HKLM\\\"Software\"\\\"test\"\\hello\\\\some\\value", true, @"HKLM\Software\test\hello", @"some\value")]
-    public void GetQueryPartsTest(string query, bool expectedHasValueName, string expectedQueryKey, string expectedQueryValueName)
-    {
-        var hasValueName = QueryHelper.GetQueryParts(query, out var queryKey, out var queryValueName);
-
-        Assert.AreEqual(expectedHasValueName, hasValueName);
-        Assert.AreEqual(expectedQueryKey, queryKey);
-        Assert.AreEqual(expectedQueryValueName, queryValueName);
-    }
-
-    [TestMethod]
-    [DataRow(@"HKCR\*\OpenWithList", @"HKEY_CLASSES_ROOT\*\OpenWithList")]
-    [DataRow(@"HKCU\Control Panel\Accessibility", @"HKEY_CURRENT_USER\Control Panel\Accessibility")]
-    [DataRow(@"HKLM\HARDWARE\UEFI", @"HKEY_LOCAL_MACHINE\HARDWARE\UEFI")]
-    [DataRow(@"HKU\.DEFAULT\Environment", @"HKEY_USERS\.DEFAULT\Environment")]
-    [DataRow(@"HKCC\System\CurrentControlSet\Control", @"HKEY_CURRENT_CONFIG\System\CurrentControlSet\Control")]
-    [DataRow(@"HKPD\???", @"HKEY_PERFORMANCE_DATA\???")]
-    public void GetShortBaseKeyTest(string registryKeyShort, string registryKeyFull)
-    {
-        Assert.AreEqual(registryKeyShort, QueryHelper.GetKeyWithShortBaseKey(registryKeyFull));
-    }
-}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Registry.UnitTests/RegistryHelperTest.cs

@@ -1,75 +0,0 @@
-// 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.Collections;
-using System.Linq;
-
-using Microsoft.CmdPal.Ext.Registry.Helpers;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace Microsoft.CmdPal.Ext.Registry.UnitTests;
-
-[TestClass]
-public class RegistryHelperTest
-{
-    [TestMethod]
-    [DataRow(@"HKCC\System\CurrentControlSet\Control", "HKEY_CURRENT_CONFIG")]
-    [DataRow(@"HKCR\*\OpenWithList", "HKEY_CLASSES_ROOT")]
-    [DataRow(@"HKCU\Control Panel\Accessibility", "HKEY_CURRENT_USER")]
-    [DataRow(@"HKLM\HARDWARE\UEFI", "HKEY_LOCAL_MACHINE")]
-    [DataRow(@"HKPD\???", "HKEY_PERFORMANCE_DATA")]
-    [DataRow(@"HKU\.DEFAULT\Environment", "HKEY_USERS")]
-    public void GetRegistryBaseKeyTestOnlyOneBaseKey(string query, string expectedBaseKey)
-    {
-        var (baseKeyList, _) = RegistryHelper.GetRegistryBaseKey(query);
-        Assert.IsNotNull(baseKeyList);
-        Assert.IsTrue(baseKeyList.Count() == 1);
-        Assert.AreEqual(expectedBaseKey, baseKeyList.First().Name);
-    }
-
-    [TestMethod]
-    public void GetRegistryBaseKeyTestMoreThanOneBaseKey()
-    {
-        var (baseKeyList, _) = RegistryHelper.GetRegistryBaseKey("HKC\\Control Panel\\Accessibility"); /* #no-spell-check-line */
-
-        Assert.IsNotNull(baseKeyList);
-        Assert.IsTrue(baseKeyList.Count() > 1);
-
-        var list = baseKeyList.Select(found => found.Name);
-        Assert.IsTrue(list.Contains("HKEY_CLASSES_ROOT"));
-        Assert.IsTrue(list.Contains("HKEY_CURRENT_CONFIG"));
-        Assert.IsTrue(list.Contains("HKEY_CURRENT_USER"));
-    }
-
-    [TestMethod]
-    [DataRow(@"HKCR\*\OpenWithList", @"*\OpenWithList")]
-    [DataRow(@"HKCU\Control Panel\Accessibility", @"Control Panel\Accessibility")]
-    [DataRow(@"HKLM\HARDWARE\UEFI", @"HARDWARE\UEFI")]
-    [DataRow(@"HKU\.DEFAULT\Environment", @".DEFAULT\Environment")]
-    [DataRow(@"HKCC\System\CurrentControlSet\Control", @"System\CurrentControlSet\Control")]
-    [DataRow(@"HKPD\???", @"???")]
-    public void GetRegistryBaseKeyTestSubKey(string query, string expectedSubKey)
-    {
-        var (_, subKey) = RegistryHelper.GetRegistryBaseKey(query);
-        Assert.AreEqual(expectedSubKey, subKey);
-    }
-
-    [TestMethod]
-    public void GetAllBaseKeysTest()
-    {
-        var list = RegistryHelper.GetAllBaseKeys();
-
-        CollectionAssert.AllItemsAreNotNull((ICollection)list);
-        CollectionAssert.AllItemsAreUnique((ICollection)list);
-
-        var keys = list.Select(found => found.Key).ToList() as ICollection;
-
-        CollectionAssert.Contains(keys, Win32.Registry.ClassesRoot);
-        CollectionAssert.Contains(keys, Win32.Registry.CurrentConfig);
-        CollectionAssert.Contains(keys, Win32.Registry.CurrentUser);
-        CollectionAssert.Contains(keys, Win32.Registry.LocalMachine);
-        CollectionAssert.Contains(keys, Win32.Registry.PerformanceData);
-        CollectionAssert.Contains(keys, Win32.Registry.Users);
-    }
-}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Registry.UnitTests/ResultHelperTest.cs

@@ -1,32 +0,0 @@
-// 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.Linq;
-using Microsoft.CmdPal.Ext.Registry.Helpers;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace Microsoft.CmdPal.Ext.Registry.UnitTests;
-
-[TestClass]
-public class ResultHelperTest
-{
-    [TestMethod]
-    [DataRow(@"HKEY_CLASSES_ROOT\*\OpenWithList", @"HKEY_CLASSES_ROOT\*\OpenWithList")]
-    [DataRow(@"HKEY_CURRENT_USER\Control Panel\Accessibility", @"HKEY_CURRENT_USER\Control Panel\Accessibility")]
-    [DataRow(@"HKEY_LOCAL_MACHINE\HARDWARE\UEFI", @"HKEY_LOCAL_MACHINE\HARDWARE\UEFI")]
-    [DataRow(@"HKEY_USERS\.DEFAULT\Environment", @"HKEY_USERS\.DEFAULT\Environment")]
-    [DataRow(@"HKCC\System\CurrentControlSet\Control", @"HKEY_CURRENT_CONFIG\System\CurrentControlSet\Control")]
-    [DataRow(@"HKEY_PERFORMANCE_DATA\???", @"HKEY_PERFORMANCE_DATA\???")]
-    [DataRow(@"HKCR\*\shell\Open with VS Code\command", @"HKEY_CLASSES_ROOT\*\shell\Open with VS Code\command")]
-    [DataRow(@"...ndows\CurrentVersion\Explorer\StartupApproved", @"HKEY_CURRENT_USER\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved")]
-    [DataRow(@"...p\Upgrade\NetworkDriverBackup\Control\Network", @"HKEY_LOCAL_MACHINE\SYSTEM\Setup\Upgrade\NetworkDriverBackup\Control\Network")]
-    [DataRow(@"...anel\International\User Profile System Backup", @"HKEY_USERS\.DEFAULT\Control Panel\International\User Profile System Backup")]
-    [DataRow(@"...stem\CurrentControlSet\Control\Print\Printers", @"HKEY_CURRENT_CONFIG\System\CurrentControlSet\Control\Print\Printers")]
-    public void GetTruncatedTextTest_StandardCases(string registryKeyShort, string registryKeyFull)
-    {
-        Assert.AreEqual(registryKeyShort, ResultHelper.GetTruncatedText(registryKeyFull, 45));
-    }
-}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.System.UnitTests/BasicTests.cs

@@ -1,84 +0,0 @@
-// 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 Microsoft.CmdPal.Ext.System.Helpers;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace Microsoft.CmdPal.Ext.System.UnitTests;
-
-[TestClass]
-public class BasicTests
-{
-    [TestMethod]
-    public void CommandsHelperTest()
-    {
-        // Setup & Act
-        var commands = Commands.GetSystemCommands(false, false, false, false);
-
-        // Assert
-        Assert.IsNotNull(commands);
-        Assert.IsTrue(commands.Count > 0);
-    }
-
-    [TestMethod]
-    public void IconsHelperTest()
-    {
-        // Assert
-        Assert.IsNotNull(Icons.FirmwareSettingsIcon);
-        Assert.IsNotNull(Icons.LockIcon);
-        Assert.IsNotNull(Icons.LogoffIcon);
-        Assert.IsNotNull(Icons.NetworkAdapterIcon);
-        Assert.IsNotNull(Icons.RecycleBinIcon);
-        Assert.IsNotNull(Icons.RestartIcon);
-        Assert.IsNotNull(Icons.RestartShellIcon);
-        Assert.IsNotNull(Icons.ShutdownIcon);
-        Assert.IsNotNull(Icons.SleepIcon);
-    }
-
-    [TestMethod]
-    public void Win32HelpersTest()
-    {
-        // Setup & Act
-        // These methods should not throw exceptions
-        var firmwareType = Win32Helpers.GetSystemFirmwareType();
-
-        // Assert
-        // Just testing that they don't throw exceptions
-        Assert.IsTrue(Enum.IsDefined(typeof(FirmwareType), firmwareType));
-    }
-
-    [TestMethod]
-    public void NetworkConnectionPropertiesTest()
-    {
-        // Test that network connection properties can be accessed without throwing exceptions
-        try
-        {
-            var networkPropertiesList = NetworkConnectionProperties.GetList();
-
-            // If we have network connections, test accessing their properties
-            if (networkPropertiesList.Count > 0)
-            {
-                var networkProperties = networkPropertiesList[0];
-
-                // Access properties (these used to be methods)
-                var ipv4 = networkProperties.IPv4;
-                var ipv6 = networkProperties.IPv6Primary;
-                var macAddress = networkProperties.PhysicalAddress;
-
-                // Test passes if no exceptions are thrown
-                Assert.IsTrue(true);
-            }
-            else
-            {
-                // If no network connections, test still passes
-                Assert.IsTrue(true);
-            }
-        }
-        catch
-        {
-            Assert.Fail("Network properties should not throw exceptions");
-        }
-    }
-}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.System.UnitTests/ImageTests.cs

@@ -1,72 +0,0 @@
-// 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.Linq;
-using System.Reflection;
-using Microsoft.CmdPal.Ext.System.Helpers;
-using Microsoft.CmdPal.Ext.System.Pages;
-using Microsoft.CommandPalette.Extensions;
-using Microsoft.CommandPalette.Extensions.Toolkit;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace Microsoft.CmdPal.Ext.System.UnitTests;
-
-[TestClass]
-public class ImageTests
-{
-    [DataTestMethod]
-    [DataRow("shutdown", "ShutdownIcon")]
-    [DataRow("restart", "RestartIcon")]
-    [DataRow("sign out", "LogoffIcon")]
-    [DataRow("lock", "LockIcon")]
-    [DataRow("sleep", "SleepIcon")]
-    [DataRow("hibernate", "SleepIcon")]
-    [DataRow("recycle bin", "RecycleBinIcon")]
-    [DataRow("uefi firmware settings", "FirmwareSettingsIcon")]
-    [DataRow("IPv4 addr", "NetworkAdapterIcon")]
-    [DataRow("IPV6 addr", "NetworkAdapterIcon")]
-    [DataRow("MAC addr", "NetworkAdapterIcon")]
-    public void IconThemeDarkTest(string typedString, string expectedIconPropertyName)
-    {
-        var systemPage = new SystemCommandPage(new SettingsManager());
-
-        foreach (var item in systemPage.GetItems())
-        {
-            if (item.Title.Contains(typedString, StringComparison.OrdinalIgnoreCase) || item.Subtitle.Contains(typedString, StringComparison.OrdinalIgnoreCase))
-            {
-                var icon = item.Icon;
-                Assert.IsNotNull(icon, $"Icon for '{typedString}' should not be null.");
-                Assert.IsNotEmpty(icon.Dark.Icon, $"Icon for '{typedString}' should not be empty.");
-            }
-        }
-    }
-
-    [DataTestMethod]
-    [DataRow("shutdown", "ShutdownIcon")]
-    [DataRow("restart", "RestartIcon")]
-    [DataRow("sign out", "LogoffIcon")]
-    [DataRow("lock", "LockIcon")]
-    [DataRow("sleep", "SleepIcon")]
-    [DataRow("hibernate", "SleepIcon")]
-    [DataRow("recycle bin", "RecycleBinIcon")]
-    [DataRow("uefi firmware settings", "FirmwareSettingsIcon")]
-    [DataRow("IPv4 addr", "NetworkAdapterIcon")]
-    [DataRow("IPV6 addr", "NetworkAdapterIcon")]
-    [DataRow("MAC addr", "NetworkAdapterIcon")]
-    public void IconThemeLightTest(string typedString, string expectedIconPropertyName)
-    {
-        var systemPage = new SystemCommandPage(new SettingsManager());
-
-        foreach (var item in systemPage.GetItems())
-        {
-            if (item.Title.Contains(typedString, StringComparison.OrdinalIgnoreCase) || item.Subtitle.Contains(typedString, StringComparison.OrdinalIgnoreCase))
-            {
-                var icon = item.Icon;
-                Assert.IsNotNull(icon, $"Icon for '{typedString}' should not be null.");
-                Assert.IsNotEmpty(icon.Light.Icon, $"Icon for '{typedString}' should not be empty.");
-            }
-        }
-    }
-}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.System.UnitTests/Microsoft.CmdPal.Ext.System.UnitTests.csproj

@@ -1,24 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <!-- Look at Directory.Build.props in root for common stuff as well -->
-  <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
-
-  <PropertyGroup>
-    <IsPackable>false</IsPackable>
-    <IsTestProject>true</IsTestProject>
-    <RootNamespace>Microsoft.CmdPal.Ext.System.UnitTests</RootNamespace>
-    <OutputPath>$(SolutionDir)$(Platform)\$(Configuration)\WinUI3Apps\CmdPal\tests\</OutputPath>
-    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
-    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Moq" />
-    <PackageReference Include="MSTest" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\..\common\ManagedCommon\ManagedCommon.csproj" />
-    <ProjectReference Include="..\..\ext\Microsoft.CmdPal.Ext.System\Microsoft.CmdPal.Ext.System.csproj" />
-    <ProjectReference Include="..\..\extensionsdk\Microsoft.CommandPalette.Extensions.Toolkit\Microsoft.CommandPalette.Extensions.Toolkit.csproj" />
-  </ItemGroup>
-</Project>

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.System.UnitTests/QueryTests.cs

@@ -1,105 +0,0 @@
-// 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.Linq;
-using Microsoft.CmdPal.Ext.System.Helpers;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace Microsoft.CmdPal.Ext.System.UnitTests;
-
-[TestClass]
-public class QueryTests
-{
-    [DataTestMethod]
-    [DataRow("shutdown", "Shutdown")]
-    [DataRow("restart", "Restart")]
-    [DataRow("sign out", "Sign out")]
-    [DataRow("lock", "Lock")]
-    [DataRow("sleep", "Sleep")]
-    [DataRow("hibernate", "Hibernate")]
-    public void SystemCommandsTest(string typedString, string expectedCommand)
-    {
-        // Setup
-        var commands = Commands.GetSystemCommands(false, false, false, false);
-
-        // Act
-        var result = commands.Where(c => c.Title.Contains(expectedCommand, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
-
-        // Assert
-        Assert.IsNotNull(result);
-        Assert.IsTrue(result.Title.Contains(expectedCommand, StringComparison.OrdinalIgnoreCase));
-    }
-
-    [TestMethod]
-    public void RecycleBinCommandTest()
-    {
-        // Setup
-        var commands = Commands.GetSystemCommands(false, false, false, false);
-
-        // Act
-        var result = commands.Where(c => c.Title.Contains("Recycle", StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
-
-        // Assert
-        Assert.IsNotNull(result);
-    }
-
-    [TestMethod]
-    public void NetworkCommandsTest()
-    {
-        // Test that network commands can be retrieved
-        try
-        {
-            var networkPropertiesList = NetworkConnectionProperties.GetList();
-            Assert.IsTrue(networkPropertiesList.Count >= 0); // Should not throw exceptions
-        }
-        catch (Exception ex)
-        {
-            Assert.Fail($"Network commands should not throw exceptions: {ex.Message}");
-        }
-    }
-
-    [TestMethod]
-    public void UefiCommandIsAvailableTest()
-    {
-        // Setup
-        var firmwareType = Win32Helpers.GetSystemFirmwareType();
-        var isUefiMode = firmwareType == FirmwareType.Uefi;
-
-        // Act
-        var commands = Commands.GetSystemCommands(isUefiMode, false, false, false);
-        var uefiCommand = commands.Where(c => c.Title.Contains("UEFI", StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
-
-        // Assert
-        if (isUefiMode)
-        {
-            Assert.IsNotNull(uefiCommand);
-        }
-        else
-        {
-            // UEFI command may still exist but be disabled on non-UEFI systems
-            Assert.IsTrue(true); // Test environment independent
-        }
-    }
-
-    [TestMethod]
-    public void FirmwareTypeTest()
-    {
-        // Test that GetSystemFirmwareType returns a valid enum value
-        var firmwareType = Win32Helpers.GetSystemFirmwareType();
-        Assert.IsTrue(Enum.IsDefined(typeof(FirmwareType), firmwareType));
-    }
-
-    [TestMethod]
-    public void EmptyRecycleBinCommandTest()
-    {
-        // Test that empty recycle bin command exists
-        var commands = Commands.GetSystemCommands(false, false, false, false);
-        var result = commands.Where(c => c.Title.Contains("Empty", StringComparison.OrdinalIgnoreCase) &&
-                                         c.Title.Contains("Recycle", StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
-
-        // Empty recycle bin command should exist
-        Assert.IsNotNull(result);
-    }
-}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/AvailableResultsListTests.cs

@@ -1,494 +0,0 @@
-// 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.Globalization;
-using System.Linq;
-using Microsoft.CmdPal.Ext.TimeDate.Helpers;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace Microsoft.CmdPal.Ext.TimeDate.UnitTests;
-
-[TestClass]
-public class AvailableResultsListTests
-{
-    private CultureInfo originalCulture;
-    private CultureInfo originalUiCulture;
-
-    [TestInitialize]
-    public void Setup()
-    {
-        // Set culture to 'en-us'
-        originalCulture = CultureInfo.CurrentCulture;
-        CultureInfo.CurrentCulture = new CultureInfo("en-us", false);
-        originalUiCulture = CultureInfo.CurrentUICulture;
-        CultureInfo.CurrentUICulture = new CultureInfo("en-us", false);
-    }
-
-    [TestCleanup]
-    public void CleanUp()
-    {
-        // Set culture to original value
-        CultureInfo.CurrentCulture = originalCulture;
-        CultureInfo.CurrentUICulture = originalUiCulture;
-    }
-
-    private DateTime GetDateTimeForTest(bool embedUtc = false)
-    {
-        var dateTime = new DateTime(2022, 03, 02, 22, 30, 45);
-        if (embedUtc)
-        {
-            return DateTime.SpecifyKind(dateTime, DateTimeKind.Utc);
-        }
-        else
-        {
-            return dateTime;
-        }
-    }
-
-    [DataTestMethod]
-    [DataRow("time", "10:30 PM")]
-    [DataRow("date", "3/2/2022")]
-    [DataRow("date and time", "3/2/2022 10:30 PM")]
-    [DataRow("hour", "22")]
-    [DataRow("minute", "30")]
-    [DataRow("second", "45")]
-    [DataRow("millisecond", "0")]
-    [DataRow("day (week day)", "Wednesday")]
-    [DataRow("day of the week (week day)", "4")]
-    [DataRow("day of the month", "2")]
-    [DataRow("day of the year", "61")]
-    [DataRow("week of the month", "1")]
-    [DataRow("week of the year (calendar week, week number)", "10")]
-    [DataRow("month", "March")]
-    [DataRow("month of the year", "3")]
-    [DataRow("month and day", "March 2")]
-    [DataRow("year", "2022")]
-    [DataRow("month and year", "March 2022")]
-    [DataRow("ISO 8601", "2022-03-02T22:30:45")]
-    [DataRow("ISO 8601 with time zone", "2022-03-02T22:30:45")]
-    [DataRow("RFC1123", "Wed, 02 Mar 2022 22:30:45 GMT")]
-    [DataRow("Date and time in filename-compatible format", "2022-03-02_22-30-45")]
-    public void LocalFormatsWithShortTimeAndShortDate(string formatLabel, string expectedResult)
-    {
-        // Setup
-        var settings = new SettingsManager();
-        var helperResults = AvailableResultsList.GetList(true, settings, false, false, GetDateTimeForTest());
-
-        // Act
-        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
-
-        // Assert
-        Assert.AreEqual(expectedResult, result?.Value, $"Culture {CultureInfo.CurrentCulture.Name}, Culture UI: {CultureInfo.CurrentUICulture.Name}, Calendar: {CultureInfo.CurrentCulture.Calendar}, Region: {RegionInfo.CurrentRegion.Name}");
-    }
-
-    [TestMethod]
-    public void GetList_WithKeywordSearch_ReturnsResults()
-    {
-        // Setup
-        var settings = new SettingsManager();
-
-        // Act
-        var results = AvailableResultsList.GetList(true, settings);
-
-        // Assert
-        Assert.IsNotNull(results);
-        Assert.IsTrue(results.Count > 0, "Should return at least some results for keyword search");
-    }
-
-    [TestMethod]
-    public void GetList_WithoutKeywordSearch_ReturnsResults()
-    {
-        // Setup
-        var settings = new SettingsManager();
-
-        // Act
-        var results = AvailableResultsList.GetList(false, settings);
-
-        // Assert
-        Assert.IsNotNull(results);
-        Assert.IsTrue(results.Count > 0, "Should return at least some results for non-keyword search");
-    }
-
-    [TestMethod]
-    public void GetList_WithSpecificDateTime_ReturnsFormattedResults()
-    {
-        // Setup
-        var settings = new SettingsManager();
-        var specificDateTime = GetDateTimeForTest();
-
-        // Act
-        var results = AvailableResultsList.GetList(true, settings, null, null, specificDateTime);
-
-        // Assert
-        Assert.IsNotNull(results);
-        Assert.IsTrue(results.Count > 0, "Should return results for specific datetime");
-
-        // Verify that all results have values
-        foreach (var result in results)
-        {
-            Assert.IsNotNull(result.Label, "Result label should not be null");
-            Assert.IsNotNull(result.Value, "Result value should not be null");
-        }
-    }
-
-    [TestMethod]
-    public void GetList_ResultsHaveRequiredProperties()
-    {
-        // Setup
-        var settings = new SettingsManager();
-
-        // Act
-        var results = AvailableResultsList.GetList(true, settings);
-
-        // Assert
-        Assert.IsTrue(results.Count > 0, "Should have results");
-
-        foreach (var result in results)
-        {
-            Assert.IsNotNull(result.Label, "Each result should have a label");
-            Assert.IsNotNull(result.Value, "Each result should have a value");
-            Assert.IsFalse(string.IsNullOrWhiteSpace(result.Label), "Label should not be empty");
-            Assert.IsFalse(string.IsNullOrWhiteSpace(result.Value), "Value should not be empty");
-        }
-    }
-
-    [TestMethod]
-    public void GetList_WithDifferentCalendarSettings_ReturnsResults()
-    {
-        // Setup
-        var settings = new SettingsManager();
-
-        // Act & Assert - Test with different settings
-        var results1 = AvailableResultsList.GetList(true, settings);
-        Assert.IsNotNull(results1);
-        Assert.IsTrue(results1.Count > 0);
-
-        // Test that the method can handle different calendar settings
-        var results2 = AvailableResultsList.GetList(false, settings);
-        Assert.IsNotNull(results2);
-        Assert.IsTrue(results2.Count > 0);
-    }
-
-    [DataTestMethod]
-    [DataRow("time", "10:30 PM")]
-    [DataRow("date", "Wednesday, March 2, 2022")]
-    [DataRow("date and time", "Wednesday, March 2, 2022 10:30 PM")]
-    [DataRow("hour", "22")]
-    [DataRow("minute", "30")]
-    [DataRow("second", "45")]
-    [DataRow("millisecond", "0")]
-    [DataRow("day (week day)", "Wednesday")]
-    [DataRow("day of the week (week day)", "4")]
-    [DataRow("day of the month", "2")]
-    [DataRow("day of the year", "61")]
-    [DataRow("week of the month", "1")]
-    [DataRow("week of the year (calendar week, week number)", "10")]
-    [DataRow("month", "March")]
-    [DataRow("month of the year", "3")]
-    [DataRow("month and day", "March 2")]
-    [DataRow("year", "2022")]
-    [DataRow("month and year", "March 2022")]
-    [DataRow("ISO 8601", "2022-03-02T22:30:45")]
-    [DataRow("ISO 8601 with time zone", "2022-03-02T22:30:45")]
-    [DataRow("RFC1123", "Wed, 02 Mar 2022 22:30:45 GMT")]
-    [DataRow("Date and time in filename-compatible format", "2022-03-02_22-30-45")]
-    public void LocalFormatsWithShortTimeAndLongDate(string formatLabel, string expectedResult)
-    {
-        // Setup
-        var settings = new SettingsManager();
-        var helperResults = AvailableResultsList.GetList(true, settings, false, true, GetDateTimeForTest());
-
-        // Act
-        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
-
-        // Assert
-        Assert.AreEqual(expectedResult, result?.Value);
-    }
-
-    [DataTestMethod]
-    [DataRow("time", "10:30:45 PM")]
-    [DataRow("date", "3/2/2022")]
-    [DataRow("date and time", "3/2/2022 10:30:45 PM")]
-    [DataRow("hour", "22")]
-    [DataRow("minute", "30")]
-    [DataRow("second", "45")]
-    [DataRow("millisecond", "0")]
-    [DataRow("day (week day)", "Wednesday")]
-    [DataRow("day of the week (week day)", "4")]
-    [DataRow("day of the month", "2")]
-    [DataRow("day of the year", "61")]
-    [DataRow("week of the month", "1")]
-    [DataRow("week of the year (calendar week, week number)", "10")]
-    [DataRow("month", "March")]
-    [DataRow("month of the year", "3")]
-    [DataRow("month and day", "March 2")]
-    [DataRow("year", "2022")]
-    [DataRow("month and year", "March 2022")]
-    [DataRow("ISO 8601", "2022-03-02T22:30:45")]
-    [DataRow("ISO 8601 with time zone", "2022-03-02T22:30:45")]
-    [DataRow("RFC1123", "Wed, 02 Mar 2022 22:30:45 GMT")]
-    [DataRow("Date and time in filename-compatible format", "2022-03-02_22-30-45")]
-    public void LocalFormatsWithLongTimeAndShortDate(string formatLabel, string expectedResult)
-    {
-        // Setup
-        var settings = new SettingsManager();
-        var helperResults = AvailableResultsList.GetList(true, settings, true, false, GetDateTimeForTest());
-
-        // Act
-        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
-
-        // Assert
-        Assert.AreEqual(expectedResult, result?.Value);
-    }
-
-    [DataTestMethod]
-    [DataRow("time", "10:30:45 PM")]
-    [DataRow("date", "Wednesday, March 2, 2022")]
-    [DataRow("date and time", "Wednesday, March 2, 2022 10:30:45 PM")]
-    [DataRow("hour", "22")]
-    [DataRow("minute", "30")]
-    [DataRow("second", "45")]
-    [DataRow("millisecond", "0")]
-    [DataRow("day (week day)", "Wednesday")]
-    [DataRow("day of the week (week day)", "4")]
-    [DataRow("day of the month", "2")]
-    [DataRow("day of the year", "61")]
-    [DataRow("week of the month", "1")]
-    [DataRow("week of the year (calendar week, week number)", "10")]
-    [DataRow("month", "March")]
-    [DataRow("month of the year", "3")]
-    [DataRow("month and day", "March 2")]
-    [DataRow("year", "2022")]
-    [DataRow("month and year", "March 2022")]
-    [DataRow("ISO 8601", "2022-03-02T22:30:45")]
-    [DataRow("ISO 8601 with time zone", "2022-03-02T22:30:45")]
-    [DataRow("RFC1123", "Wed, 02 Mar 2022 22:30:45 GMT")]
-    [DataRow("Date and time in filename-compatible format", "2022-03-02_22-30-45")]
-    public void LocalFormatsWithLongTimeAndLongDate(string formatLabel, string expectedResult)
-    {
-        // Setup
-        var settings = new SettingsManager();
-        var helperResults = AvailableResultsList.GetList(true, settings, true, true, GetDateTimeForTest());
-
-        // Act
-        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
-
-        // Assert
-        Assert.AreEqual(expectedResult, result?.Value);
-    }
-
-    [DataTestMethod]
-    [DataRow("time utc", "t")]
-    [DataRow("date and time utc", "g")]
-    [DataRow("ISO 8601 UTC", "yyyy-MM-ddTHH:mm:ss")]
-    [DataRow("ISO 8601 UTC with time zone", "yyyy-MM-ddTHH:mm:ss'Z'")]
-    [DataRow("Universal time format: YYYY-MM-DD hh:mm:ss", "u")]
-    [DataRow("Date and time in filename-compatible format", "yyyy-MM-dd_HH-mm-ss")]
-    public void UtcFormatsWithShortTimeAndShortDate(string formatLabel, string expectedFormat)
-    {
-        // Setup
-        var settings = new SettingsManager();
-        var helperResults = AvailableResultsList.GetList(true, settings, false, false, GetDateTimeForTest(true));
-        var expectedResult = GetDateTimeForTest().ToString(expectedFormat, CultureInfo.CurrentCulture);
-
-        // Act
-        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
-
-        // Assert
-        Assert.AreEqual(expectedResult, result?.Value);
-    }
-
-    [DataTestMethod]
-    [DataRow("time utc", "t")]
-    [DataRow("date and time utc", "f")]
-    [DataRow("ISO 8601 UTC", "yyyy-MM-ddTHH:mm:ss")]
-    [DataRow("ISO 8601 UTC with time zone", "yyyy-MM-ddTHH:mm:ss'Z'")]
-    [DataRow("Universal time format: YYYY-MM-DD hh:mm:ss", "u")]
-    [DataRow("Date and time in filename-compatible format", "yyyy-MM-dd_HH-mm-ss")]
-    public void UtcFormatsWithShortTimeAndLongDate(string formatLabel, string expectedFormat)
-    {
-        // Setup
-        var settings = new SettingsManager();
-        var helperResults = AvailableResultsList.GetList(true, settings, false, true, GetDateTimeForTest(true));
-        var expectedResult = GetDateTimeForTest().ToString(expectedFormat, CultureInfo.CurrentCulture);
-
-        // Act
-        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
-
-        // Assert
-        Assert.AreEqual(expectedResult, result?.Value);
-    }
-
-    [DataTestMethod]
-    [DataRow("time utc", "T")]
-    [DataRow("date and time utc", "G")]
-    [DataRow("ISO 8601 UTC", "yyyy-MM-ddTHH:mm:ss")]
-    [DataRow("ISO 8601 UTC with time zone", "yyyy-MM-ddTHH:mm:ss'Z'")]
-    [DataRow("Universal time format: YYYY-MM-DD hh:mm:ss", "u")]
-    [DataRow("Date and time in filename-compatible format", "yyyy-MM-dd_HH-mm-ss")]
-    public void UtcFormatsWithLongTimeAndShortDate(string formatLabel, string expectedFormat)
-    {
-        // Setup
-        var settings = new SettingsManager();
-        var helperResults = AvailableResultsList.GetList(true, settings, true, false, GetDateTimeForTest(true));
-        var expectedResult = GetDateTimeForTest().ToString(expectedFormat, CultureInfo.CurrentCulture);
-
-        // Act
-        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
-
-        // Assert
-        Assert.AreEqual(expectedResult, result?.Value);
-    }
-
-    [DataTestMethod]
-    [DataRow("time utc", "T")]
-    [DataRow("date and time utc", "F")]
-    [DataRow("ISO 8601 UTC", "yyyy-MM-ddTHH:mm:ss")]
-    [DataRow("ISO 8601 UTC with time zone", "yyyy-MM-ddTHH:mm:ss'Z'")]
-    [DataRow("Universal time format: YYYY-MM-DD hh:mm:ss", "u")]
-    [DataRow("Date and time in filename-compatible format", "yyyy-MM-dd_HH-mm-ss")]
-    public void UtcFormatsWithLongTimeAndLongDate(string formatLabel, string expectedFormat)
-    {
-        // Setup
-        var settings = new SettingsManager();
-        var helperResults = AvailableResultsList.GetList(true, settings, true, true, GetDateTimeForTest(true));
-        var expectedResult = GetDateTimeForTest().ToString(expectedFormat, CultureInfo.CurrentCulture);
-
-        // Act
-        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
-
-        // Assert
-        Assert.AreEqual(expectedResult, result?.Value);
-    }
-
-    [TestMethod]
-    public void UnixTimestampSecondsFormat()
-    {
-        // Setup
-        string formatLabel = "Unix epoch time";
-        DateTime timeValue = DateTime.Now.ToUniversalTime();
-        var settings = new SettingsManager();
-        var helperResults = AvailableResultsList.GetList(true, settings, null, null, timeValue);
-        var expectedResult = (long)timeValue.Subtract(new DateTime(1970, 1, 1)).TotalSeconds;
-
-        // Act
-        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
-
-        // Assert
-        Assert.AreEqual(expectedResult.ToString(CultureInfo.CurrentCulture), result?.Value);
-    }
-
-    [TestMethod]
-    public void UnixTimestampMillisecondsFormat()
-    {
-        // Setup
-        string formatLabel = "Unix epoch time in milliseconds";
-        DateTime timeValue = DateTime.Now.ToUniversalTime();
-        var settings = new SettingsManager();
-        var helperResults = AvailableResultsList.GetList(true, settings, null, null, timeValue);
-        var expectedResult = (long)timeValue.Subtract(new DateTime(1970, 1, 1)).TotalMilliseconds;
-
-        // Act
-        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
-
-        // Assert
-        Assert.AreEqual(expectedResult.ToString(CultureInfo.CurrentCulture), result?.Value);
-    }
-
-    [TestMethod]
-    public void WindowsFileTimeFormat()
-    {
-        // Setup
-        string formatLabel = "Windows file time (Int64 number)";
-        DateTime timeValue = DateTime.Now;
-        var settings = new SettingsManager();
-        var helperResults = AvailableResultsList.GetList(true, settings, null, null, timeValue);
-        var expectedResult = timeValue.ToFileTime().ToString(CultureInfo.CurrentCulture);
-
-        // Act
-        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
-
-        // Assert
-        Assert.AreEqual(expectedResult, result?.Value);
-    }
-
-    [TestMethod]
-    public void ValidateEraResult()
-    {
-        // Setup
-        string formatLabel = "Era";
-        DateTime timeValue = DateTime.Now;
-        var settings = new SettingsManager();
-        var helperResults = AvailableResultsList.GetList(true, settings, null, null, timeValue);
-        var expectedResult = DateTimeFormatInfo.CurrentInfo.GetEraName(CultureInfo.CurrentCulture.Calendar.GetEra(timeValue));
-
-        // Act
-        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
-
-        // Assert
-        Assert.AreEqual(expectedResult, result?.Value);
-    }
-
-    [TestMethod]
-    public void ValidateEraAbbreviationResult()
-    {
-        // Setup
-        string formatLabel = "Era abbreviation";
-        DateTime timeValue = DateTime.Now;
-        var settings = new SettingsManager();
-        var helperResults = AvailableResultsList.GetList(true, settings, null, null, timeValue);
-        var expectedResult = DateTimeFormatInfo.CurrentInfo.GetAbbreviatedEraName(CultureInfo.CurrentCulture.Calendar.GetEra(timeValue));
-
-        // Act
-        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
-
-        // Assert
-        Assert.AreEqual(expectedResult, result?.Value);
-    }
-
-    [DataTestMethod]
-    [DataRow(CalendarWeekRule.FirstDay, "3")]
-    [DataRow(CalendarWeekRule.FirstFourDayWeek, "2")]
-    [DataRow(CalendarWeekRule.FirstFullWeek, "2")]
-    public void DifferentFirstWeekSettingConfigurations(CalendarWeekRule weekRule, string expectedWeekOfYear)
-    {
-        // Setup
-        DateTime timeValue = new DateTime(2021, 1, 12);
-        var settings = new SettingsManager();
-        var helperResults = AvailableResultsList.GetList(true, settings, null, null, timeValue, weekRule, DayOfWeek.Sunday);
-
-        // Act
-        var resultWeekOfYear = helperResults.FirstOrDefault(x => x.Label.Equals("week of the year (calendar week, week number)", StringComparison.OrdinalIgnoreCase));
-
-        // Assert
-        Assert.AreEqual(expectedWeekOfYear, resultWeekOfYear?.Value);
-    }
-
-    [DataTestMethod]
-    [DataRow(DayOfWeek.Monday, "2", "2", "5")]
-    [DataRow(DayOfWeek.Tuesday, "3", "3", "4")]
-    [DataRow(DayOfWeek.Wednesday, "3", "3", "3")]
-    [DataRow(DayOfWeek.Thursday, "3", "3", "2")]
-    [DataRow(DayOfWeek.Friday, "3", "3", "1")]
-    [DataRow(DayOfWeek.Saturday, "2", "2", "7")]
-    [DataRow(DayOfWeek.Sunday, "2", "2", "6")]
-    public void DifferentFirstDayOfWeekSettingConfigurations(DayOfWeek dayOfWeek, string expectedWeekOfYear, string expectedWeekOfMonth, string expectedDayInWeek)
-    {
-        // Setup
-        DateTime timeValue = new DateTime(2024, 1, 12); // Friday
-        var settings = new SettingsManager();
-        var helperResults = AvailableResultsList.GetList(true, settings, null, null, timeValue, CalendarWeekRule.FirstDay, dayOfWeek);
-
-        // Act
-        var resultWeekOfYear = helperResults.FirstOrDefault(x => x.Label.Equals("week of the year (calendar week, week number)", StringComparison.OrdinalIgnoreCase));
-        var resultWeekOfMonth = helperResults.FirstOrDefault(x => x.Label.Equals("week of the month", StringComparison.OrdinalIgnoreCase));
-        var resultDayInWeek = helperResults.FirstOrDefault(x => x.Label.Equals("day of the week (week day)", StringComparison.OrdinalIgnoreCase));
-
-        // Assert
-        Assert.AreEqual(expectedWeekOfYear, resultWeekOfYear?.Value);
-        Assert.AreEqual(expectedWeekOfMonth, resultWeekOfMonth?.Value);
-        Assert.AreEqual(expectedDayInWeek, resultDayInWeek?.Value);
-    }
-}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/BasicTests.cs

@@ -1,28 +0,0 @@
-// 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 Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace Microsoft.CmdPal.Ext.TimeDate.UnitTests;
-
-[TestClass]
-public class BasicTests
-{
-    [TestMethod]
-    public void BasicTest()
-    {
-        // This is a basic test to verify the test project can run
-        Assert.IsTrue(true);
-    }
-
-    [TestMethod]
-    public void DateTimeTest()
-    {
-        // Test basic DateTime functionality
-        var now = DateTime.Now;
-        Assert.IsNotNull(now);
-        Assert.IsTrue(now > DateTime.MinValue);
-    }
-}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/FallbackTimeDateItemTests.cs

@@ -1,86 +0,0 @@
-// 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.Globalization;
-using Microsoft.CmdPal.Ext.TimeDate.Helpers;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace Microsoft.CmdPal.Ext.TimeDate.UnitTests;
-
-[TestClass]
-public class FallbackTimeDateItemTests
-{
-    private CultureInfo originalCulture;
-    private CultureInfo originalUiCulture;
-
-    [TestInitialize]
-    public void Setup()
-    {
-        // Set culture to 'en-us'
-        originalCulture = CultureInfo.CurrentCulture;
-        CultureInfo.CurrentCulture = new CultureInfo("en-us", false);
-        originalUiCulture = CultureInfo.CurrentUICulture;
-        CultureInfo.CurrentUICulture = new CultureInfo("en-us", false);
-    }
-
-    [TestCleanup]
-    public void Cleanup()
-    {
-        // Restore original culture
-        CultureInfo.CurrentCulture = originalCulture;
-        CultureInfo.CurrentUICulture = originalUiCulture;
-    }
-
-    [DataTestMethod]
-    [DataRow("time", "12:00 PM")]
-    [DataRow("date", "7/1/2025")]
-    [DataRow("week", "27")]
-    public void FallbackQueryTests(string query, string expectedTitle)
-    {
-        // Setup
-        var settingsManager = new SettingsManager();
-        DateTime now = new DateTime(2025, 7, 1, 12, 0, 0); // Fixed date for testing
-        var fallbackItem = new FallbackTimeDateItem(settingsManager, now);
-
-        // Act & Assert - Test that UpdateQuery doesn't throw exceptions
-        try
-        {
-            fallbackItem.UpdateQuery(query);
-            Assert.IsTrue(
-                fallbackItem.Title.Contains(expectedTitle, StringComparison.OrdinalIgnoreCase),
-                $"Expected title to contain '{expectedTitle}', but got '{fallbackItem.Title}'");
-            Assert.IsNotNull(fallbackItem.Subtitle, "Subtitle should not be null");
-            Assert.IsNotNull(fallbackItem.Icon, "Icon should not be null");
-        }
-        catch (Exception ex)
-        {
-            Assert.Fail($"UpdateQuery should not throw exceptions: {ex.Message}");
-        }
-    }
-
-    [DataTestMethod]
-    [DataRow(null)]
-    [DataRow("invalid input")]
-    public void InvalidQueryTests(string query)
-    {
-        // Setup
-        var settingsManager = new SettingsManager();
-        DateTime now = new DateTime(2025, 7, 1, 12, 0, 0); // Fixed date for testing
-        var fallbackItem = new FallbackTimeDateItem(settingsManager, now);
-
-        // Act & Assert - Test that UpdateQuery doesn't throw exceptions
-        try
-        {
-            fallbackItem.UpdateQuery(query);
-
-            Assert.AreEqual(string.Empty, fallbackItem.Title, "Title should be empty for invalid queries");
-            Assert.AreEqual(string.Empty, fallbackItem.Subtitle, "Subtitle should be empty for invalid queries");
-        }
-        catch (Exception ex)
-        {
-            Assert.Fail($"UpdateQuery should not throw exceptions: {ex.Message}");
-        }
-    }
-}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/IconTests.cs

@@ -1,127 +0,0 @@
-// 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.Globalization;
-using Microsoft.CmdPal.Ext.TimeDate.Helpers;
-using Microsoft.CommandPalette.Extensions.Toolkit;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace Microsoft.CmdPal.Ext.TimeDate.UnitTests;
-
-[TestClass]
-public class IconTests
-{
-    private CultureInfo originalCulture;
-    private CultureInfo originalUiCulture;
-
-    [TestInitialize]
-    public void Setup()
-    {
-        // Set culture to 'en-us'
-        originalCulture = CultureInfo.CurrentCulture;
-        CultureInfo.CurrentCulture = new CultureInfo("en-us", false);
-        originalUiCulture = CultureInfo.CurrentUICulture;
-        CultureInfo.CurrentUICulture = new CultureInfo("en-us", false);
-    }
-
-    [TestCleanup]
-    public void CleanUp()
-    {
-        // Set culture to original value
-        CultureInfo.CurrentCulture = originalCulture;
-        CultureInfo.CurrentUICulture = originalUiCulture;
-    }
-
-    [TestMethod]
-    public void TimeDateCommandsProvider_HasIcon()
-    {
-        // Setup
-        var provider = new TimeDateCommandsProvider();
-
-        // Act
-        var icon = provider.Icon;
-
-        // Assert
-        Assert.IsNotNull(icon, "Provider should have an icon");
-    }
-
-    [TestMethod]
-    public void TimeDateCommandsProvider_TopLevelCommands_HaveIcons()
-    {
-        // Setup
-        var provider = new TimeDateCommandsProvider();
-
-        // Act
-        var commands = provider.TopLevelCommands();
-
-        // Assert
-        Assert.IsNotNull(commands);
-        Assert.IsTrue(commands.Length > 0, "Should have at least one top-level command");
-
-        foreach (var command in commands)
-        {
-            Assert.IsNotNull(command.Icon, "Each command should have an icon");
-        }
-    }
-
-    [TestMethod]
-    public void AvailableResults_HaveIcons()
-    {
-        // Setup
-        var settings = new SettingsManager();
-
-        // Act
-        var results = AvailableResultsList.GetList(true, settings);
-
-        // Assert
-        Assert.IsNotNull(results);
-        Assert.IsTrue(results.Count > 0, "Should have results");
-
-        foreach (var result in results)
-        {
-            Assert.IsNotNull(result.GetIconInfo(), $"Result '{result.Label}' should have an icon");
-        }
-    }
-
-    [DataTestMethod]
-    [DataRow(ResultIconType.Time, "\uE823")]
-    [DataRow(ResultIconType.Date, "\uE787")]
-    [DataRow(ResultIconType.DateTime, "\uEC92")]
-    public void ResultHelper_CreateListItem_PreservesIcon(ResultIconType resultIconType, string expectedIcon)
-    {
-        // Setup
-        var availableResult = new AvailableResult
-        {
-            Label = "Test Label",
-            Value = "Test Value",
-            IconType = resultIconType,
-        };
-
-        // Act
-        var listItem = availableResult.ToListItem();
-
-        var icon = listItem.Icon;
-
-        // Assert
-        Assert.IsNotNull(listItem);
-        Assert.IsNotNull(listItem.Icon, "ListItem should preserve the icon from AvailableResult");
-        Assert.AreEqual(expectedIcon, icon.Dark.Icon, $"Icon for {resultIconType} should match expected value");
-    }
-
-    [TestMethod]
-    public void Icons_AreNotEmpty()
-    {
-        // Setup
-        var settings = new SettingsManager();
-        var results = AvailableResultsList.GetList(true, settings);
-
-        // Act & Assert
-        foreach (var result in results)
-        {
-            Assert.IsNotNull(result.GetIconInfo(), $"Result '{result.Label}' should have an icon");
-            Assert.IsFalse(string.IsNullOrWhiteSpace(result.GetIconInfo().ToString()), $"Icon for '{result.Label}' should not be empty");
-        }
-    }
-}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/Microsoft.CmdPal.Ext.TimeDate.UnitTests.csproj

@@ -1,23 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <!-- Look at Directory.Build.props in root for common stuff as well -->
-  <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
-
-  <PropertyGroup>
-    <IsPackable>false</IsPackable>
-    <IsTestProject>true</IsTestProject>
-    <RootNamespace>Microsoft.CmdPal.Ext.TimeDate.UnitTests</RootNamespace>
-    <OutputPath>$(SolutionDir)$(Platform)\$(Configuration)\WinUI3Apps\CmdPal\tests\</OutputPath>
-    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
-    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Moq" />
-    <PackageReference Include="MSTest" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\..\common\ManagedCommon\ManagedCommon.csproj" />
-    <ProjectReference Include="..\..\ext\Microsoft.CmdPal.Ext.TimeDate\Microsoft.CmdPal.Ext.TimeDate.csproj" />
-  </ItemGroup>
-</Project>

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/QueryTests.cs

@@ -1,350 +0,0 @@
-// 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.Globalization;
-using System.Linq;
-using Microsoft.CmdPal.Ext.TimeDate.Helpers;
-using Microsoft.CommandPalette.Extensions.Toolkit;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace Microsoft.CmdPal.Ext.TimeDate.UnitTests;
-
-[TestClass]
-public class QueryTests
-{
-    private CultureInfo originalCulture;
-    private CultureInfo originalUiCulture;
-
-    [TestInitialize]
-    public void Setup()
-    {
-        // Set culture to 'en-us'
-        originalCulture = CultureInfo.CurrentCulture;
-        CultureInfo.CurrentCulture = new CultureInfo("en-us", false);
-        originalUiCulture = CultureInfo.CurrentUICulture;
-        CultureInfo.CurrentUICulture = new CultureInfo("en-us", false);
-    }
-
-    [TestCleanup]
-    public void CleanUp()
-    {
-        // Set culture to original value
-        CultureInfo.CurrentCulture = originalCulture;
-        CultureInfo.CurrentUICulture = originalUiCulture;
-    }
-
-    [DataTestMethod]
-    [DataRow("time", 1)] // Common time queries should return results
-    [DataRow("date", 1)] // Common date queries should return results
-    [DataRow("now", 1)] // Now should return multiple results
-    [DataRow("current", 1)] // Current should return multiple results
-    [DataRow("year", 1)] // Year-related queries should return results
-    [DataRow("time::10:10:10", 1)] // Specific time format should return results
-    [DataRow("date::10/10/10", 1)] // Specific date format should return results
-    public void CountBasicQueries(string query, int expectedMinResultCount)
-    {
-        // Setup
-        var settings = new SettingsManager();
-
-        // Act
-        var results = TimeDateCalculator.ExecuteSearch(settings, query);
-
-        // Assert
-        Assert.IsTrue(
-            results.Count >= expectedMinResultCount,
-            $"Expected at least {expectedMinResultCount} results for query '{query}', but got {results.Count}");
-    }
-
-    [DataTestMethod]
-    [DataRow("time")]
-    [DataRow("date")]
-    [DataRow("year")]
-    [DataRow("now")]
-    [DataRow("current")]
-    [DataRow("")]
-    [DataRow("now::10:10:10")] // Windows file time
-    public void AllQueriesReturnResults(string query)
-    {
-        // Setup
-        var settings = new SettingsManager();
-
-        // Act
-        var results = TimeDateCalculator.ExecuteSearch(settings, query);
-
-        // Assert
-        Assert.IsNotNull(results);
-        Assert.IsTrue(results.Count > 0, $"Query '{query}' should return at least one result");
-    }
-
-    [DataTestMethod]
-    [DataRow("time", "Time")]
-    [DataRow("date", "Date")]
-    [DataRow("now", "Now")]
-    [DataRow("unix", "Unix epoch time")]
-    [DataRow("unix epoch time in milli", "Unix epoch time in milliseconds")]
-    [DataRow("file", "Windows file time (Int64 number)")]
-    [DataRow("hour", "Hour")]
-    [DataRow("minute", "Minute")]
-    [DataRow("second", "Second")]
-    [DataRow("millisecond", "Millisecond")]
-    [DataRow("day", "Day (Week day)")]
-    [DataRow("day of week", "Day of the week (Week day)")]
-    [DataRow("day of month", "Day of the month")]
-    [DataRow("day of year", "Day of the year")]
-    [DataRow("week of month", "Week of the month")]
-    [DataRow("week of year", "Week of the year (Calendar week, Week number)")]
-    [DataRow("month", "Month")]
-    [DataRow("month of year", "Month of the year")]
-    [DataRow("month and d", "Month and day")]
-    [DataRow("month and y", "Month and year")]
-    [DataRow("year", "Year")]
-    [DataRow("era", "Era")]
-    [DataRow("era a", "Era abbreviation")]
-    [DataRow("universal", "Universal time format: YYYY-MM-DD hh:mm:ss")]
-    [DataRow("iso", "ISO 8601")]
-    [DataRow("rfc", "RFC1123")]
-    [DataRow("time::12:30", "Time")]
-    [DataRow("date::10.10.2022", "Date")]
-    [DataRow("time::u1646408119", "Time")]
-    [DataRow("time::ft637820085517321977", "Time")]
-    [DataRow("week day", "Day (Week day)")]
-    [DataRow("cal week", "Week of the year (Calendar week, Week number)")]
-    [DataRow("week num", "Week of the year (Calendar week, Week number)")]
-    [DataRow("days in mo", "Days in month")]
-    [DataRow("Leap y", "Leap year")]
-    public void CanFindFormatResult(string query, string expectedSubtitle)
-    {
-        // Setup
-        var settings = new SettingsManager();
-
-        // Act
-        var results = TimeDateCalculator.ExecuteSearch(settings, query);
-
-        // Assert
-        var matchingResult = results.FirstOrDefault(x => x.Subtitle?.StartsWith(expectedSubtitle, StringComparison.CurrentCulture) == true);
-        Assert.IsNotNull(matchingResult, $"Could not find result with subtitle starting with '{expectedSubtitle}' for query '{query}'");
-    }
-
-    [DataTestMethod]
-    [DataRow("12:30", "Time")]
-    [DataRow("10.10.2022", "Date")]
-    [DataRow("u1646408119", "Date and time")]
-    [DataRow("u+1646408119", "Date and time")]
-    [DataRow("u-1646408119", "Date and time")]
-    [DataRow("ums1646408119", "Date and time")]
-    [DataRow("ums+1646408119", "Date and time")]
-    [DataRow("ums-1646408119", "Date and time")]
-    [DataRow("ft637820085517321977", "Date and time")]
-    public void DateTimeNumberOnlyInput(string query, string expectedSubtitle)
-    {
-        // Setup
-        var settings = new SettingsManager();
-
-        // Act
-        var results = TimeDateCalculator.ExecuteSearch(settings, query);
-
-        // Assert
-        var matchingResult = results.FirstOrDefault(x => x.Subtitle?.StartsWith(expectedSubtitle, StringComparison.CurrentCulture) == true);
-        Assert.IsNotNull(matchingResult, $"Could not find result with subtitle starting with '{expectedSubtitle}' for query '{query}'");
-    }
-
-    [DataTestMethod]
-    [DataRow("abcdefg")]
-    [DataRow("timmmmeeee")]
-    [DataRow("timtaaaetetaae::u1646408119")]
-    [DataRow("time:eeee")]
-    [DataRow("time::eeee")]
-    [DataRow("time//eeee")]
-    public void InvalidInputShowsErrorResults(string query)
-    {
-        // Setup
-        var settings = new SettingsManager();
-
-        // Act
-        var results = TimeDateCalculator.ExecuteSearch(settings, query);
-
-        // Assert
-        Assert.IsNotNull(results, $"Results should not be null for query '{query}'");
-        Assert.IsTrue(results.Count > 0, $"Query '{query}' should return at least one result");
-
-        // For invalid input, cmdpal returns an error result
-        var hasErrorResult = results.Any(r => r.Title?.StartsWith("Error: Invalid input", StringComparison.CurrentCulture) == true);
-        Assert.IsTrue(hasErrorResult, $"Query '{query}' should return an error result for invalid input");
-    }
-
-    [DataTestMethod]
-    [DataRow("ug1646408119")] // Invalid prefix
-    [DataRow("u9999999999999")] // Unix number + prefix is longer than 12 characters
-    [DataRow("ums999999999999999")] // Unix number in milliseconds + prefix is longer than 17 characters
-    [DataRow("-u99999999999")] // Unix number with wrong placement of - sign
-    [DataRow("+ums9999999999")] // Unix number in milliseconds with wrong placement of + sign
-    [DataRow("0123456")] // Missing prefix
-    [DataRow("ft63782008ab55173dasdas21977")] // Number contains letters
-    [DataRow("ft63782008ab55173dasdas")] // Number contains letters at the end
-    [DataRow("ft12..548")] // Number contains wrong punctuation
-    [DataRow("ft12..54//8")] // Number contains wrong punctuation and other characters
-    [DataRow("time::ft12..54//8")] // Number contains wrong punctuation and other characters
-    [DataRow("ut2ed.5555")] // Number contains letters
-    [DataRow("12..54//8")] // Number contains punctuation and other characters, but no special prefix
-    [DataRow("ft::1288gg8888")] // Number contains delimiter and letters, but no special prefix
-    [DataRow("date::12::55")]
-    [DataRow("date::12:aa:55")]
-    [DataRow("10.aa.22")]
-    [DataRow("12::55")]
-    [DataRow("12:aa:55")]
-    public void InvalidNumberInputShowsErrorMessage(string query)
-    {
-        // Setup
-        var settings = new SettingsManager();
-
-        // Act
-        var results = TimeDateCalculator.ExecuteSearch(settings, query);
-
-        // Assert
-        Assert.IsNotNull(results, $"Results should not be null for query '{query}'");
-        Assert.IsTrue(results.Count > 0, $"Should return at least one result (error message) for invalid query '{query}'");
-
-        // Check if we get an error result
-        var errorResult = results.FirstOrDefault(r => r.Title?.StartsWith("Error: Invalid input", StringComparison.CurrentCulture) == true);
-        Assert.IsNotNull(errorResult, $"Should return an error result for invalid query '{query}'");
-    }
-
-    [DataTestMethod]
-    [DataRow("10.10aa")] // Input contains <Number>.<Number> (Can be part of a date.)
-    [DataRow("10:10aa")] // Input contains <Number>:<Number> (Can be part of a time.)
-    [DataRow("10/10aa")] // Input contains <Number>/<Number> (Can be part of a date.)
-    public void InvalidInputNotShowsErrorMessage(string query)
-    {
-        // Setup
-        var settings = new SettingsManager();
-
-        // Act
-        var results = TimeDateCalculator.ExecuteSearch(settings, query);
-
-        // Assert
-        Assert.IsNotNull(results, $"Results should not be null for query '{query}'");
-
-        // These queries are ambiguous and cmdpal returns an error for them
-        // This test might need to be adjusted based on actual cmdpal behavior
-        if (results.Count > 0)
-        {
-            var hasErrorResult = results.Any(r => r.Title?.StartsWith("Error: Invalid input", StringComparison.CurrentCulture) == true);
-
-            // For these ambiguous inputs, cmdpal may return error results, which is acceptable
-            // We just verify that the system handles them gracefully (doesn't crash)
-            Assert.IsTrue(true, $"Query '{query}' handled gracefully");
-        }
-    }
-
-    [DataTestMethod]
-    [DataRow("time", "time", true)] // Full word match should work
-    [DataRow("date", "date", true)] // Full word match should work
-    [DataRow("now", "now", true)] // Full word match should work
-    [DataRow("year", "year", true)] // Full word match should work
-    [DataRow("abcdefg", "", false)] // Invalid query should return error
-    public void ValidateBehaviorOnSearchQueries(string query, string expectedMatchTerm, bool shouldHaveValidResults)
-    {
-        // Setup
-        var settings = new SettingsManager();
-
-        // Act
-        var results = TimeDateCalculator.ExecuteSearch(settings, query);
-
-        // Assert
-        Assert.IsNotNull(results, $"Results should not be null for query '{query}'");
-        Assert.IsTrue(results.Count > 0, $"Query '{query}' should return at least one result");
-
-        if (shouldHaveValidResults)
-        {
-            // Should have non-error results
-            var hasValidResult = results.Any(r => !r.Title?.StartsWith("Error: Invalid input", StringComparison.CurrentCulture) == true);
-            Assert.IsTrue(hasValidResult, $"Query '{query}' should return valid (non-error) results");
-
-            if (!string.IsNullOrEmpty(expectedMatchTerm))
-            {
-                var hasMatchingResult = results.Any(r =>
-                    r.Title?.Contains(expectedMatchTerm, StringComparison.CurrentCultureIgnoreCase) == true ||
-                    r.Subtitle?.Contains(expectedMatchTerm, StringComparison.CurrentCultureIgnoreCase) == true);
-                Assert.IsTrue(hasMatchingResult, $"Query '{query}' should return results containing '{expectedMatchTerm}'");
-            }
-        }
-        else
-        {
-            // Should have error results
-            var hasErrorResult = results.Any(r => r.Title?.StartsWith("Error: Invalid input", StringComparison.CurrentCulture) == true);
-            Assert.IsTrue(hasErrorResult, $"Query '{query}' should return error results for invalid input");
-        }
-    }
-
-    [TestMethod]
-    public void EmptyQueryReturnsAllResults()
-    {
-        // Setup
-        var settings = new SettingsManager();
-
-        // Act
-        var results = TimeDateCalculator.ExecuteSearch(settings, string.Empty);
-
-        // Assert
-        Assert.IsNotNull(results);
-        Assert.IsTrue(results.Count > 0, "Empty query should return all available results");
-    }
-
-    [TestMethod]
-    public void NullQueryReturnsAllResults()
-    {
-        // Setup
-        var settings = new SettingsManager();
-
-        // Act
-        var results = TimeDateCalculator.ExecuteSearch(settings, null);
-
-        // Assert
-        Assert.IsNotNull(results);
-        Assert.IsTrue(results.Count > 0, "Null query should return all available results");
-    }
-
-    [DataTestMethod]
-    [DataRow("time u", "Time UTC")]
-    [DataRow("now u", "Now UTC")]
-    [DataRow("iso utc", "ISO 8601 UTC")]
-    [DataRow("iso zone", "ISO 8601 with time zone")]
-    [DataRow("iso utc zone", "ISO 8601 UTC with time zone")]
-    public void UTCRelatedQueries(string query, string expectedSubtitle)
-    {
-        // Setup
-        var settings = new SettingsManager();
-
-        // Act
-        var results = TimeDateCalculator.ExecuteSearch(settings, query);
-
-        // Assert
-        Assert.IsNotNull(results);
-        Assert.IsTrue(results.Count > 0, $"Query '{query}' should return results");
-
-        var matchingResult = results.FirstOrDefault(x => x.Subtitle?.StartsWith(expectedSubtitle, StringComparison.CurrentCulture) == true);
-        Assert.IsNotNull(matchingResult, $"Could not find result with subtitle starting with '{expectedSubtitle}' for query '{query}'");
-    }
-
-    [DataTestMethod]
-    [DataRow("time::12:30:45")]
-    [DataRow("date::2023-12-25")]
-    [DataRow("now::u1646408119")]
-    [DataRow("current::ft637820085517321977")]
-    public void DelimiterQueriesReturnResults(string query)
-    {
-        // Setup
-        var settings = new SettingsManager();
-
-        // Act
-        var results = TimeDateCalculator.ExecuteSearch(settings, query);
-
-        // Assert
-        Assert.IsNotNull(results);
-
-        // Delimiter queries should return results even if parsing fails (error results)
-        Assert.IsTrue(results.Count > 0, $"Delimiter query '{query}' should return at least one result");
-    }
-}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/ResultHelperTests.cs

@@ -1,143 +0,0 @@
-// 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.Globalization;
-using Microsoft.CmdPal.Ext.TimeDate.Helpers;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace Microsoft.CmdPal.Ext.TimeDate.UnitTests;
-
-[TestClass]
-public class ResultHelperTests
-{
-    private CultureInfo originalCulture;
-    private CultureInfo originalUiCulture;
-
-    [TestInitialize]
-    public void Setup()
-    {
-        // Set culture to 'en-us'
-        originalCulture = CultureInfo.CurrentCulture;
-        CultureInfo.CurrentCulture = new CultureInfo("en-us", false);
-        originalUiCulture = CultureInfo.CurrentUICulture;
-        CultureInfo.CurrentUICulture = new CultureInfo("en-us", false);
-    }
-
-    [TestCleanup]
-    public void CleanUp()
-    {
-        // Set culture to original value
-        CultureInfo.CurrentCulture = originalCulture;
-        CultureInfo.CurrentUICulture = originalUiCulture;
-    }
-
-    [TestMethod]
-    public void ResultHelper_CreateListItem_ReturnsValidItem()
-    {
-        // Setup
-        var availableResult = new AvailableResult
-        {
-            Label = "Test Label",
-            Value = "Test Value",
-        };
-
-        // Act
-        var listItem = availableResult.ToListItem();
-
-        // Assert
-        Assert.IsNotNull(listItem);
-        Assert.AreEqual("Test Value", listItem.Title);
-        Assert.AreEqual("Test Label", listItem.Subtitle);
-    }
-
-    [TestMethod]
-    public void ResultHelper_CreateListItem_HandlesNullInput()
-    {
-        AvailableResult availableResult = null;
-
-        // Act & Assert
-        Assert.ThrowsException<System.NullReferenceException>(() => availableResult.ToListItem());
-    }
-
-    [TestMethod]
-    public void ResultHelper_CreateListItem_HandlesEmptyValues()
-    {
-        // Setup
-        var availableResult = new AvailableResult
-        {
-            Label = string.Empty,
-            Value = string.Empty,
-        };
-
-        // Act
-        var listItem = availableResult.ToListItem();
-
-        // Assert
-        Assert.IsNotNull(listItem);
-        Assert.AreEqual("Copy", listItem.Title);
-        Assert.AreEqual(string.Empty, listItem.Subtitle);
-    }
-
-    [TestMethod]
-    public void ResultHelper_CreateListItem_WithIcon()
-    {
-        // Setup
-        var availableResult = new AvailableResult
-        {
-            Label = "Test Label",
-            Value = "Test Value",
-            IconType = ResultIconType.Date,
-        };
-
-        // Act
-        var listItem = availableResult.ToListItem();
-
-        // Assert
-        Assert.IsNotNull(listItem);
-        Assert.AreEqual("Test Value", listItem.Title);
-        Assert.AreEqual("Test Label", listItem.Subtitle);
-        Assert.IsNotNull(listItem.Icon);
-    }
-
-    [TestMethod]
-    public void ResultHelper_CreateListItem_WithLongText()
-    {
-        // Setup
-        var longText = new string('A', 1000);
-        var availableResult = new AvailableResult
-        {
-            Label = longText,
-            Value = longText,
-        };
-
-        // Act
-        var listItem = availableResult.ToListItem();
-
-        // Assert
-        Assert.IsNotNull(listItem);
-        Assert.AreEqual(longText, listItem.Title);
-        Assert.AreEqual(longText, listItem.Subtitle);
-    }
-
-    [TestMethod]
-    public void ResultHelper_CreateListItem_WithSpecialCharacters()
-    {
-        // Setup
-        var specialText = "Test & < > \" ' \n \t";
-        var availableResult = new AvailableResult
-        {
-            Label = specialText,
-            Value = specialText,
-        };
-
-        // Act
-        var listItem = availableResult.ToListItem();
-
-        // Assert
-        Assert.IsNotNull(listItem);
-        Assert.AreEqual(specialText, listItem.Title);
-        Assert.AreEqual(specialText, listItem.Subtitle);
-    }
-}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/SettingsManagerTests.cs

@@ -1,85 +0,0 @@
-// 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.Globalization;
-using Microsoft.CmdPal.Ext.TimeDate.Helpers;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace Microsoft.CmdPal.Ext.TimeDate.UnitTests;
-
-[TestClass]
-public class SettingsManagerTests
-{
-    private CultureInfo originalCulture;
-    private CultureInfo originalUiCulture;
-
-    [TestInitialize]
-    public void Setup()
-    {
-        // Set culture to 'en-us'
-        originalCulture = CultureInfo.CurrentCulture;
-        CultureInfo.CurrentCulture = new CultureInfo("en-us", false);
-        originalUiCulture = CultureInfo.CurrentUICulture;
-        CultureInfo.CurrentUICulture = new CultureInfo("en-us", false);
-    }
-
-    [TestCleanup]
-    public void Cleanup()
-    {
-        // Restore original culture
-        CultureInfo.CurrentCulture = originalCulture;
-        CultureInfo.CurrentUICulture = originalUiCulture;
-    }
-
-    [TestMethod]
-    public void SettingsManagerInitializationTest()
-    {
-        // Act
-        var settingsManager = new SettingsManager();
-
-        // Assert
-        Assert.IsNotNull(settingsManager);
-        Assert.IsNotNull(settingsManager.Settings);
-    }
-
-    [TestMethod]
-    public void DefaultSettingsValidation()
-    {
-        // Act
-        var settingsManager = new SettingsManager();
-
-        // Assert - Check that properties are accessible
-        var enableFallback = settingsManager.EnableFallbackItems;
-        var timeWithSecond = settingsManager.TimeWithSecond;
-        var dateWithWeekday = settingsManager.DateWithWeekday;
-        var firstWeekOfYear = settingsManager.FirstWeekOfYear;
-        var firstDayOfWeek = settingsManager.FirstDayOfWeek;
-        var customFormats = settingsManager.CustomFormats;
-
-        Assert.IsNotNull(customFormats);
-    }
-
-    [TestMethod]
-    public void SettingsPropertiesAccessibilityTest()
-    {
-        // Setup
-        var settingsManager = new SettingsManager();
-
-        // Act & Assert - Verify all properties are accessible without exception
-        try
-        {
-            _ = settingsManager.EnableFallbackItems;
-            _ = settingsManager.TimeWithSecond;
-            _ = settingsManager.DateWithWeekday;
-            _ = settingsManager.FirstWeekOfYear;
-            _ = settingsManager.FirstDayOfWeek;
-            _ = settingsManager.CustomFormats;
-        }
-        catch (Exception ex)
-        {
-            Assert.Fail($"Settings properties should be accessible: {ex.Message}");
-        }
-    }
-}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/StringParserTests.cs

@@ -1,135 +0,0 @@
-// 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.Globalization;
-using Microsoft.CmdPal.Ext.TimeDate.Helpers;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace Microsoft.CmdPal.Ext.TimeDate.UnitTests;
-
-[TestClass]
-public class StringParserTests
-{
-    private CultureInfo originalCulture;
-    private CultureInfo originalUiCulture;
-
-    [TestInitialize]
-    public void Setup()
-    {
-        // Set culture to 'en-us'
-        originalCulture = CultureInfo.CurrentCulture;
-        CultureInfo.CurrentCulture = new CultureInfo("en-us", false);
-        originalUiCulture = CultureInfo.CurrentUICulture;
-        CultureInfo.CurrentUICulture = new CultureInfo("en-us", false);
-    }
-
-    [DataTestMethod]
-    [DataRow("10/29/2022 17:05:10", true, "G", "10/29/2022 5:05:10 PM")]
-    [DataRow("Saturday, October 29, 2022 5:05:10 PM", true, "G", "10/29/2022 5:05:10 PM")]
-    [DataRow("10/29/2022", true, "d", "10/29/2022")]
-    [DataRow("Saturday, October 29, 2022", true, "d", "10/29/2022")]
-    [DataRow("17:05:10", true, "T", "5:05:10 PM")]
-    [DataRow("5:05:10 PM", true, "T", "5:05:10 PM")]
-    [DataRow("10456", false, "", "")]
-    [DataRow("u10456", true, "", "")] // Value is UTC and can be different based on system
-    [DataRow("u-10456", true, "", "")] // Value is UTC and can be different based on system
-    [DataRow("u+10456", true, "", "")] // Value is UTC and can be different based on system
-    [DataRow("ums10456", true, "", "")] // Value is UTC and can be different based on system
-    [DataRow("ums-10456", true, "", "")] // Value is UTC and can be different based on system
-    [DataRow("ums+10456", true, "", "")] // Value is UTC and can be different based on system
-    [DataRow("ft10456", true, "", "")] // Value is UTC and can be different based on system
-    [DataRow("oa-657434.99999999", true, "G", "1/1/0100 11:59:59 PM")]
-    [DataRow("oa2958465.99999999", true, "G", "12/31/9999 11:59:59 PM")]
-    [DataRow("oa-657435", false, "", "")] // Value to low
-    [DataRow("oa2958466", false, "", "")] // Value to large
-    [DataRow("exc1.99998843", true, "G", "1/1/1900 11:59:59 PM")]
-    [DataRow("exc59.99998843", true, "G", "2/28/1900 11:59:59 PM")]
-    [DataRow("exc61", true, "G", "3/1/1900 12:00:00 AM")]
-    [DataRow("exc62.99998843", true, "G", "3/2/1900 11:59:59 PM")]
-    [DataRow("exc2958465.99998843", true, "G", "12/31/9999 11:59:59 PM")]
-    [DataRow("exc0", false, "", "")] // Day 0 means in Excel 0/1/1900 and this is a fake date.
-    [DataRow("exc0.99998843", false, "", "")] // Day 0 means in Excel 0/1/1900 and this is a fake date.
-    [DataRow("exc60.99998843", false, "", "")] // Day 60 means in Excel 2/29/1900 and this is a fake date in Excel which we cannot support.
-    [DataRow("exc60", false, "", "")] // Day 60 means in Excel 2/29/1900 and this is a fake date in Excel which we cannot support.
-    [DataRow("exc-1", false, "", "")] // Value to low
-    [DataRow("exc2958466", false, "", "")] // Value to large
-    [DataRow("exf0.99998843", true, "G", "1/1/1904 11:59:59 PM")]
-    [DataRow("exf2957003.99998843", true, "G", "12/31/9999 11:59:59 PM")]
-    [DataRow("exf-0.5", false, "", "")] // Value to low
-    [DataRow("exf2957004", false, "", "")] // Value to large
-    public void ConvertStringToDateTime(string typedString, bool expectedBool, string stringType, string expectedString)
-    {
-        // Act
-        var boolResult = TimeAndDateHelper.ParseStringAsDateTime(in typedString, out DateTime result, out _);
-
-        // Assert
-        Assert.AreEqual(expectedBool, boolResult);
-        if (!string.IsNullOrEmpty(expectedString))
-        {
-            Assert.AreEqual(expectedString, result.ToString(stringType, CultureInfo.CurrentCulture));
-        }
-    }
-
-    [TestMethod]
-    public void ParseStringAsDateTime_BasicTest()
-    {
-        // Test basic string parsing functionality
-        var testCases = new[]
-        {
-            ("2023-12-25", true),
-            ("12/25/2023", true),
-            ("invalid date", false),
-            (string.Empty, false),
-        };
-
-        foreach (var (input, expectedSuccess) in testCases)
-        {
-            // Act
-            var result = TimeAndDateHelper.ParseStringAsDateTime(in input, out DateTime dateTime, out var errorMessage);
-
-            // Assert
-            Assert.AreEqual(expectedSuccess, result, $"Failed for input: {input}");
-            if (!expectedSuccess)
-            {
-                Assert.IsFalse(string.IsNullOrEmpty(errorMessage), $"Error message should not be empty for invalid input: {input}");
-            }
-        }
-    }
-
-    [TestMethod]
-    public void ParseStringAsDateTime_UnixTimestampTest()
-    {
-        // Test Unix timestamp parsing
-        var unixTimestamp = "u1640995200"; // 2022-01-01 00:00:00 UTC
-
-        // Act
-        var result = TimeAndDateHelper.ParseStringAsDateTime(in unixTimestamp, out DateTime dateTime, out var errorMessage);
-
-        // Assert
-        Assert.IsTrue(result, "Unix timestamp parsing should succeed");
-        Assert.IsTrue(string.IsNullOrEmpty(errorMessage), "Error message should be empty for valid Unix timestamp");
-    }
-
-    [TestMethod]
-    public void ParseStringAsDateTime_FileTimeTest()
-    {
-        // Test Windows file time parsing
-        var fileTime = "ft132857664000000000"; // Some valid file time
-
-        // Act
-        var result = TimeAndDateHelper.ParseStringAsDateTime(in fileTime, out DateTime dateTime, out var errorMessage);
-
-        // Assert
-        Assert.IsTrue(result, "File time parsing should succeed");
-    }
-
-    [TestCleanup]
-    public void CleanUp()
-    {
-        // Set culture to original value
-        CultureInfo.CurrentCulture = originalCulture;
-        CultureInfo.CurrentUICulture = originalUiCulture;
-    }
-}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/TimeAndDateHelperTests.cs

@@ -1,132 +0,0 @@
-// 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.Globalization;
-using Microsoft.CmdPal.Ext.TimeDate.Helpers;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace Microsoft.CmdPal.Ext.TimeDate.UnitTests;
-
-[TestClass]
-public class TimeAndDateHelperTests
-{
-    private CultureInfo originalCulture;
-    private CultureInfo originalUiCulture;
-
-    [TestInitialize]
-    public void Setup()
-    {
-        // Set culture to 'en-us'
-        originalCulture = CultureInfo.CurrentCulture;
-        CultureInfo.CurrentCulture = new CultureInfo("en-us", false);
-        originalUiCulture = CultureInfo.CurrentUICulture;
-        CultureInfo.CurrentUICulture = new CultureInfo("en-us", false);
-    }
-
-    [TestCleanup]
-    public void Cleanup()
-    {
-        // Restore original culture
-        CultureInfo.CurrentCulture = originalCulture;
-        CultureInfo.CurrentUICulture = originalUiCulture;
-    }
-
-    [DataTestMethod]
-    [DataRow(-1, null)] // default setting
-    [DataRow(0, CalendarWeekRule.FirstDay)]
-    [DataRow(1, CalendarWeekRule.FirstFullWeek)]
-    [DataRow(2, CalendarWeekRule.FirstFourDayWeek)]
-    [DataRow(30, null)] // wrong setting
-    public void GetCalendarWeekRuleBasedOnPluginSetting(int setting, CalendarWeekRule? valueExpected)
-    {
-        // Act
-        var result = TimeAndDateHelper.GetCalendarWeekRule(setting);
-
-        // Assert
-        if (valueExpected == null)
-        {
-            // falls back to system setting.
-            Assert.AreEqual(DateTimeFormatInfo.CurrentInfo.CalendarWeekRule, result);
-        }
-        else
-        {
-            Assert.AreEqual(valueExpected, result);
-        }
-    }
-
-    [DataTestMethod]
-    [DataRow(-1, null)] // default setting
-    [DataRow(0, DayOfWeek.Sunday)]
-    [DataRow(1, DayOfWeek.Monday)]
-    [DataRow(2, DayOfWeek.Tuesday)]
-    [DataRow(3, DayOfWeek.Wednesday)]
-    [DataRow(4, DayOfWeek.Thursday)]
-    [DataRow(5, DayOfWeek.Friday)]
-    [DataRow(6, DayOfWeek.Saturday)]
-    [DataRow(30, null)] // wrong setting
-    public void GetFirstDayOfWeekBasedOnPluginSetting(int setting, DayOfWeek? valueExpected)
-    {
-        // Act
-        var result = TimeAndDateHelper.GetFirstDayOfWeek(setting);
-
-        // Assert
-        if (valueExpected == null)
-        {
-            // falls back to system setting.
-            Assert.AreEqual(DateTimeFormatInfo.CurrentInfo.FirstDayOfWeek, result);
-        }
-        else
-        {
-            Assert.AreEqual(valueExpected, result);
-        }
-    }
-
-    [DataTestMethod]
-    [DataRow("yyyy-MM-dd", "2023-12-25")]
-    [DataRow("MM/dd/yyyy", "12/25/2023")]
-    [DataRow("dd.MM.yyyy", "25.12.2023")]
-    public void GetDateTimeFormatTest(string format, string expectedPattern)
-    {
-        // Setup
-        var testDate = new DateTime(2023, 12, 25);
-
-        // Act
-        var result = testDate.ToString(format, CultureInfo.CurrentCulture);
-
-        // Assert
-        Assert.AreEqual(expectedPattern, result);
-    }
-
-    [TestMethod]
-    public void GetCurrentTimeFormatTest()
-    {
-        // Setup
-        var testDateTime = new DateTime(2023, 12, 25, 14, 30, 45);
-
-        // Act
-        var timeResult = testDateTime.ToString("T", CultureInfo.CurrentCulture);
-        var dateResult = testDateTime.ToString("d", CultureInfo.CurrentCulture);
-
-        // Assert
-        Assert.AreEqual("2:30:45 PM", timeResult);
-        Assert.AreEqual("12/25/2023", dateResult);
-    }
-
-    [DataTestMethod]
-    [DataRow("yyyy-MM-dd HH:mm:ss", "2023-12-25 14:30:45")]
-    [DataRow("dddd, MMMM dd, yyyy", "Monday, December 25, 2023")]
-    [DataRow("HH:mm:ss tt", "14:30:45 PM")]
-    public void ValidateCustomDateTimeFormats(string format, string expectedResult)
-    {
-        // Setup
-        var testDate = new DateTime(2023, 12, 25, 14, 30, 45);
-
-        // Act
-        var result = testDate.ToString(format, CultureInfo.CurrentCulture);
-
-        // Assert
-        Assert.AreEqual(expectedResult, result);
-    }
-}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/TimeDateCalculatorTests.cs

@@ -1,124 +0,0 @@
-// 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.Globalization;
-using System.Linq;
-using Microsoft.CmdPal.Ext.TimeDate.Helpers;
-using Microsoft.CommandPalette.Extensions.Toolkit;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace Microsoft.CmdPal.Ext.TimeDate.UnitTests;
-
-[TestClass]
-public class TimeDateCalculatorTests
-{
-    private CultureInfo originalCulture;
-    private CultureInfo originalUiCulture;
-
-    [TestInitialize]
-    public void Setup()
-    {
-        // Set culture to 'en-us'
-        originalCulture = CultureInfo.CurrentCulture;
-        CultureInfo.CurrentCulture = new CultureInfo("en-us", false);
-        originalUiCulture = CultureInfo.CurrentUICulture;
-        CultureInfo.CurrentUICulture = new CultureInfo("en-us", false);
-    }
-
-    [TestCleanup]
-    public void Cleanup()
-    {
-        // Restore original culture
-        CultureInfo.CurrentCulture = originalCulture;
-        CultureInfo.CurrentUICulture = originalUiCulture;
-    }
-
-    [TestMethod]
-    public void CountAllResults()
-    {
-        // Setup
-        var settings = new SettingsManager();
-
-        // Act
-        var results = TimeDateCalculator.ExecuteSearch(settings, string.Empty);
-
-        // Assert
-        Assert.IsTrue(results.Count > 0);
-    }
-
-    [TestMethod]
-    public void ValidateEmptyQuery()
-    {
-        // Setup
-        var settings = new SettingsManager();
-
-        // Act
-        var results = TimeDateCalculator.ExecuteSearch(settings, string.Empty);
-
-        // Assert
-        Assert.IsNotNull(results);
-    }
-
-    [TestMethod]
-    public void ValidateNullQuery()
-    {
-        // Setup
-        var settings = new SettingsManager();
-
-        // Act
-        var results = TimeDateCalculator.ExecuteSearch(settings, null);
-
-        // Assert
-        Assert.IsNotNull(results);
-    }
-
-    [TestMethod]
-    public void ValidateTimeParsing()
-    {
-        // Setup
-        var settings = new SettingsManager();
-        var query = "time::10:30:45";
-
-        // Act
-        var results = TimeDateCalculator.ExecuteSearch(settings, query);
-
-        // Assert
-        Assert.IsNotNull(results);
-        Assert.IsTrue(results.Count >= 0); // May have 0 results due to invalid format, but shouldn't crash
-    }
-
-    [TestMethod]
-    public void ValidateDateParsing()
-    {
-        // Setup
-        var settings = new SettingsManager();
-        var query = "date::12/25/2023";
-
-        // Act
-        var results = TimeDateCalculator.ExecuteSearch(settings, query);
-
-        // Assert
-        Assert.IsNotNull(results);
-        Assert.IsTrue(results.Count >= 0); // May have 0 results due to invalid format, but shouldn't crash
-    }
-
-    [TestMethod]
-    public void ValidateCommonQueries()
-    {
-        // Setup
-        var settings = new SettingsManager();
-        var queries = new[] { "time", "date", "now", "current" };
-
-        foreach (var query in queries)
-        {
-            // Act
-            var results = TimeDateCalculator.ExecuteSearch(settings, query);
-
-            // Assert
-            Assert.IsNotNull(results, $"Results should not be null for query: {query}");
-        }
-    }
-}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/TimeDateCommandsProviderTests.cs

@@ -1,109 +0,0 @@
-// 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.Globalization;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace Microsoft.CmdPal.Ext.TimeDate.UnitTests
-{
-    [TestClass]
-    public class TimeDateCommandsProviderTests
-    {
-        private CultureInfo originalCulture;
-        private CultureInfo originalUiCulture;
-
-        [TestInitialize]
-        public void Setup()
-        {
-            // Set culture to 'en-us'
-            originalCulture = CultureInfo.CurrentCulture;
-            CultureInfo.CurrentCulture = new CultureInfo("en-us", false);
-            originalUiCulture = CultureInfo.CurrentUICulture;
-            CultureInfo.CurrentUICulture = new CultureInfo("en-us", false);
-        }
-
-        [TestCleanup]
-        public void Cleanup()
-        {
-            // Restore original culture
-            CultureInfo.CurrentCulture = originalCulture;
-            CultureInfo.CurrentUICulture = originalUiCulture;
-        }
-
-        [TestMethod]
-        public void TimeDateCommandsProviderInitializationTest()
-        {
-            // Act
-            var provider = new TimeDateCommandsProvider();
-
-            // Assert
-            Assert.IsNotNull(provider);
-            Assert.IsNotNull(provider.DisplayName);
-            Assert.AreEqual("DateTime", provider.Id);
-            Assert.IsNotNull(provider.Icon);
-            Assert.IsNotNull(provider.Settings);
-        }
-
-        [TestMethod]
-        public void TopLevelCommandsTest()
-        {
-            // Setup
-            var provider = new TimeDateCommandsProvider();
-
-            // Act
-            var commands = provider.TopLevelCommands();
-
-            // Assert
-            Assert.IsNotNull(commands);
-            Assert.AreEqual(1, commands.Length);
-            Assert.IsNotNull(commands[0]);
-            Assert.IsNotNull(commands[0].Title);
-            Assert.IsNotNull(commands[0].Icon);
-        }
-
-        [TestMethod]
-        public void FallbackCommandsTest()
-        {
-            // Setup
-            var provider = new TimeDateCommandsProvider();
-
-            // Act
-            var fallbackCommands = provider.FallbackCommands();
-
-            // Assert
-            Assert.IsNotNull(fallbackCommands);
-            Assert.AreEqual(1, fallbackCommands.Length);
-            Assert.IsNotNull(fallbackCommands[0]);
-        }
-
-        [TestMethod]
-        public void DisplayNameTest()
-        {
-            // Setup
-            var provider = new TimeDateCommandsProvider();
-
-            // Act
-            var displayName = provider.DisplayName;
-
-            // Assert
-            Assert.IsFalse(string.IsNullOrEmpty(displayName));
-        }
-
-        [TestMethod]
-        public void GetTranslatedPluginDescriptionTest()
-        {
-            // Setup
-            var provider = new TimeDateCommandsProvider();
-
-            // Act
-            var commands = provider.TopLevelCommands();
-            var subtitle = commands[0].Subtitle;
-
-            // Assert
-            Assert.IsFalse(string.IsNullOrEmpty(subtitle));
-            Assert.IsTrue(subtitle.Contains("Provides time and date values in different formats"));
-        }
-    }
-}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.WindowWalker.UnitTests/Microsoft.CmdPal.Ext.WindowWalker.UnitTests.csproj

@@ -1,24 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <!-- Look at Directory.Build.props in root for common stuff as well -->
-  <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
-
-  <PropertyGroup>
-    <IsPackable>false</IsPackable>
-    <IsTestProject>true</IsTestProject>
-    <RootNamespace>Microsoft.CmdPal.Ext.WindowWalker.UnitTests</RootNamespace>
-    <OutputPath>$(SolutionDir)$(Platform)\$(Configuration)\WinUI3Apps\CmdPal\tests\</OutputPath>
-    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
-    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Moq" />
-    <PackageReference Include="MSTest" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\..\common\ManagedCommon\ManagedCommon.csproj" />
-    <ProjectReference Include="..\..\ext\Microsoft.CmdPal.Ext.WindowWalker\Microsoft.CmdPal.Ext.WindowWalker.csproj" />
-    <ProjectReference Include="..\..\extensionsdk\Microsoft.CommandPalette.Extensions.Toolkit\Microsoft.CommandPalette.Extensions.Toolkit.csproj" />
-  </ItemGroup>
-</Project>

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.WindowWalker.UnitTests/PluginSettingsTests.cs

@@ -1,60 +0,0 @@
-// 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.Reflection;
-
-using Microsoft.CmdPal.Ext.WindowWalker.Helpers;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace Microsoft.CmdPal.Ext.WindowWalker.UnitTests;
-
-[TestClass]
-public class PluginSettingsTests
-{
-    [DataTestMethod]
-    [DataRow("ResultsFromVisibleDesktopOnly")]
-    [DataRow("SubtitleShowPid")]
-    [DataRow("SubtitleShowDesktopName")]
-    [DataRow("ConfirmKillProcess")]
-    [DataRow("KillProcessTree")]
-    [DataRow("OpenAfterKillAndClose")]
-    [DataRow("HideKillProcessOnElevatedProcesses")]
-    [DataRow("HideExplorerSettingInfo")]
-    [DataRow("InMruOrder")]
-    public void DoesSettingExist(string name)
-    {
-        // Setup
-        Type settings = SettingsManager.Instance?.GetType();
-
-        // Act
-        var result = settings?.GetProperty(name, BindingFlags.Public | BindingFlags.Instance);
-
-        // Assert
-        Assert.IsNotNull(result);
-    }
-
-    [DataTestMethod]
-    [DataRow("ResultsFromVisibleDesktopOnly", false)]
-    [DataRow("SubtitleShowPid", false)]
-    [DataRow("SubtitleShowDesktopName", true)]
-    [DataRow("ConfirmKillProcess", true)]
-    [DataRow("KillProcessTree", false)]
-    [DataRow("OpenAfterKillAndClose", false)]
-    [DataRow("HideKillProcessOnElevatedProcesses", false)]
-    [DataRow("HideExplorerSettingInfo", true)]
-    [DataRow("InMruOrder", true)]
-    public void DefaultValues(string name, bool valueExpected)
-    {
-        // Setup
-        SettingsManager setting = SettingsManager.Instance;
-
-        // Act
-        PropertyInfo propertyInfo = setting?.GetType()?.GetProperty(name, BindingFlags.Public | BindingFlags.Instance);
-        var result = propertyInfo?.GetValue(setting);
-
-        // Assert
-        Assert.AreEqual(valueExpected, result);
-    }
-}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Registry/Microsoft.CmdPal.Ext.Registry.csproj

@@ -10,13 +10,6 @@
     <!-- MRT from windows app sdk will search for a pri file with the same name of the module before defaulting to resources.pri -->
     <ProjectPriFileName>Microsoft.CmdPal.Ext.Registry.pri</ProjectPriFileName>
   </PropertyGroup>
-
-  <ItemGroup>
-    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
-      <_Parameter1>Microsoft.CmdPal.Ext.Registry.UnitTests</_Parameter1>
-    </AssemblyAttribute>
-  </ItemGroup>
-
   <ItemGroup>
     <PackageReference Include="System.ServiceProcess.ServiceController" />
   </ItemGroup>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.System/Microsoft.CmdPal.Ext.System.csproj

@@ -33,9 +33,4 @@
       <CustomToolNamespace>Microsoft.CmdPal.Ext.System</CustomToolNamespace>
     </EmbeddedResource>
   </ItemGroup>
-  <ItemGroup>
-    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
-      <_Parameter1>Microsoft.CmdPal.Ext.System.UnitTests</_Parameter1>
-    </AssemblyAttribute>
-  </ItemGroup>
 </Project>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.TimeDate/FallbackTimeDateItem.cs

@@ -17,16 +17,13 @@ internal sealed partial class FallbackTimeDateItem : FallbackCommandItem
 {
     private readonly HashSet<string> _validOptions;
     private SettingsManager _settingsManager;
-    private DateTime? _timestamp;
 
-    public FallbackTimeDateItem(SettingsManager settings, DateTime? timestamp = null)
+    public FallbackTimeDateItem(SettingsManager settings)
          : base(new NoOpCommand(), Resources.Microsoft_plugin_timedate_fallback_display_title)
     {
         Title = string.Empty;
         Subtitle = string.Empty;
         _settingsManager = settings;
-        _timestamp = timestamp;
-
         _validOptions = new(StringComparer.OrdinalIgnoreCase)
         {
             Resources.ResourceManager.GetString("Microsoft_plugin_timedate_SearchTagDate", CultureInfo.CurrentCulture),
@@ -52,7 +49,7 @@ internal sealed partial class FallbackTimeDateItem : FallbackCommandItem
             return;
         }
 
-        var availableResults = AvailableResultsList.GetList(false, _settingsManager, timestamp: _timestamp);
+        var availableResults = AvailableResultsList.GetList(false, _settingsManager);
         ListItem result = null;
         var maxScore = 0;
 

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.TimeDate/Helpers/TimeAndDateHelper.cs

@@ -298,7 +298,6 @@ internal static class TimeAndDateHelper
         }
         else
         {
-            inputParsingErrorMsg = Resources.Microsoft_plugin_timedate_InvalidInput_ErrorMessageTitle;
             timestamp = new DateTime(1, 1, 1, 1, 1, 1);
             Logger.LogWarning($"Failed to parse input: '{input}'. Format not recognized.");
             return false;

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.TimeDate/Microsoft.CmdPal.Ext.TimeDate.csproj

@@ -11,12 +11,6 @@
     <ProjectPriFileName>Microsoft.CmdPal.Ext.TimeDate.pri</ProjectPriFileName>
   </PropertyGroup>
 
-  <ItemGroup>
-    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
-      <_Parameter1>Microsoft.CmdPal.Ext.TimeDate.UnitTests</_Parameter1>
-    </AssemblyAttribute>
-  </ItemGroup>
-
   <ItemGroup>
     <EmbeddedResource Update="Properties\Resources.resx">
       <LastGenOutput>Resources.Designer.cs</LastGenOutput>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.WindowWalker/Microsoft.CmdPal.Ext.WindowWalker.csproj

@@ -46,9 +46,4 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
   </ItemGroup>
-  <ItemGroup>
-    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
-      <_Parameter1>Microsoft.CmdPal.Ext.WindowWalker.UnitTests</_Parameter1>
-    </AssemblyAttribute>
-  </ItemGroup>
 </Project>

src/modules/colorPicker/UITest-ColorPicker/ColorPickerUITest.cs

@@ -0,0 +1,16 @@
+// 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 Microsoft.PowerToys.UITest;
+
+namespace Microsoft.ColorPicker.UITests
+{
+    public class ColorPickerUITest : UITestBase
+    {
+        public ColorPickerUITest()
+            : base(PowerToysModule.Runner)
+        {
+        }
+    }
+}

src/modules/colorPicker/UITest-ColorPicker/ColorPickerUITest.md

@@ -0,0 +1,16 @@
+## Color Picker
+* Enable the Color Picker in settings and ensure that the hotkey brings up Color Picker
+  - [] when PowerToys is running unelevated on start-up
+  - [] when PowerToys is running as admin on start-up
+  - [] when PowerToys is restarted as admin, by clicking the restart as admin button in the settings
+- [] Change `Activate Color Picker shortcut` and check the new shortcut is working
+- [] Try all three `Activation behavior`s(`Color Picker with editor mode enabled`, `Editor`, `Color Picker only`)
+- [] Change `Color format for clipboard` and check if the correct format is copied from the Color picker
+- [] Try to copy color formats to the clipboard from the Editor
+- [] Check `Show color name` and verify if color name is shown in the Color picker
+- [] Enable one new format, disable one existing format, reorder enabled formats and check if settings are populated to the Editor
+- [] Select a color from the history in the Editor
+- [] Remove color from the history in the Editor
+- [] Open the Color Picker from the Editor
+- [] Open Adjust color from the Editor
+- [] Check Color Picker logs for errors

src/modules/colorPicker/UITest-ColorPicker/UITest-ColorPicker.csproj

@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+	<!-- Look at Directory.Build.props in root for common stuff as well -->
+	<Import Project="..\..\..\Common.Dotnet.CsWinRT.props" />
+
+	<PropertyGroup>
+		<ProjectGuid>{6880CE86-5B71-4440-9795-79A325F95747}</ProjectGuid>
+		<RootNamespace>Microsoft.ColorPicker.UITests</RootNamespace>
+		<IsPackable>false</IsPackable>
+		<Nullable>enable</Nullable>
+		<OutputType>Library</OutputType>
+
+		<!-- This is a UI test, so don't run as part of MSBuild -->
+		<RunVSTest>false</RunVSTest>
+	</PropertyGroup>
+
+	<PropertyGroup>
+		<OutputPath>..\..\..\..\$(Platform)\$(Configuration)\tests\UITests-ColorPicker\</OutputPath>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="Appium.WebDriver" />
+		<PackageReference Include="MSTest" />
+		<PackageReference Include="System.Net.Http" />
+		<PackageReference Include="System.Private.Uri" />
+		<PackageReference Include="System.Text.RegularExpressions" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<ProjectReference Include="..\..\..\common\UITestAutomation\UITestAutomation.csproj" />
+	</ItemGroup>
+
+</Project>

src/settings-ui/UITest-Settings/OOBEUITests.cs

@@ -0,0 +1,236 @@
+// 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.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.Threading.Tasks;
+using Microsoft.PowerToys.UITest;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.Settings.UITests
+{
+    [TestClass]
+    public class OOBEUITests : UITestBase
+    {
+        // Constants for file paths and identifiers
+        private const string LocalAppDataFolderPath = "%localappdata%\\Microsoft\\PowerToys";
+        private const string LastVersionFilePath = "%localappdata%\\Microsoft\\PowerToys\\last_version.txt";
+
+        public OOBEUITests()
+            : base(PowerToysModule.PowerToysSettings)
+        {
+        }
+
+        [TestMethod("OOBE.Basic.FirstStartTest")]
+        [TestCategory("OOBE test #1")]
+        public void TestOOBEFirstStart()
+        {
+            // Clean up previous PowerToys data to simulate first start
+            // CleanPowerToysData();
+
+            // Start PowerToys and verify OOBE opens
+            // StartPowerToysAndVerifyOOBEOpens();
+
+            // Navigate through all OOBE sections
+            NavigateThroughOOBESections();
+
+            // Close OOBE
+            CloseOOBE();
+
+            // Verify OOBE can be opened from Settings
+            // OpenOOBEFromSettings();
+        }
+
+        /*
+
+        [TestMethod("OOBE.WhatsNew.Test")]
+        [TestCategory("OOBE test #2")]
+        public void TestOOBEWhatsNew()
+        {
+            // Modify version file to trigger What's New
+            ModifyLastVersionFile();
+
+            // Start PowerToys and verify OOBE opens in What's New page
+            StartPowerToysAndVerifyWhatsNewOpens();
+
+            // Close OOBE
+            CloseOOBE();
+        }
+        */
+
+        private void CleanPowerToysData()
+        {
+            this.ExitScopeExe();
+
+            // Exit PowerToys if it's running
+            try
+            {
+                foreach (Process process in Process.GetProcessesByName("PowerToys"))
+                {
+                    process.Kill();
+                    process.WaitForExit();
+                }
+
+                // Delete PowerToys folder in LocalAppData
+                string powerToysFolder = Environment.ExpandEnvironmentVariables(LocalAppDataFolderPath);
+                if (Directory.Exists(powerToysFolder))
+                {
+                    Directory.Delete(powerToysFolder, true);
+                }
+
+                // Wait to ensure deletion is complete
+                Task.Delay(1000).Wait();
+            }
+            catch (Exception ex)
+            {
+                Assert.Inconclusive($"Could not clean PowerToys data: {ex.Message}");
+            }
+        }
+
+        private void StartPowerToysAndVerifyOOBEOpens()
+        {
+            try
+            {
+                // Start PowerToys
+                this.RestartScopeExe();
+
+                // Wait for OOBE window to appear
+                Task.Delay(5000).Wait();
+
+                // Verify OOBE window opened
+                Assert.IsTrue(this.Session.HasOne("Welcome to PowerToys"), "OOBE window should open with 'Welcome to PowerToys' title");
+
+                // Verify we're on the Overview page
+                Assert.IsTrue(this.Has("Overview"), "OOBE should start on Overview page");
+            }
+            catch (Exception ex)
+            {
+                Assert.Fail($"Failed to start PowerToys and verify OOBE: {ex.Message}");
+            }
+        }
+
+        private void NavigateThroughOOBESections()
+        {
+            // List of modules to test
+            string[] modules = new string[]
+            {
+                "What's new",
+                "Advanced Paste",
+            };
+
+            this.Find<NavigationViewItem>("Welcome to PowerToys").Click();
+
+            foreach (string module in modules)
+            {
+                TestModule(module);
+            }
+        }
+
+        private void TestModule(string moduleName)
+        {
+            var oobeWindow = this.Find<Window>("Welcome to PowerToys");
+            Assert.IsNotNull(oobeWindow);
+
+            /*
+                - [] open the Settings for that module
+                - [] verify the Settings work as expected (toggle some controls on/off etc.)
+                - [] close the Settings
+                - [] if it's available, test the `Launch module name` button
+                */
+            oobeWindow.Find<Button>(By.Name("Open Settings")).Click();
+
+            // Find<NavigationViewItem>("What's new").Click();
+            Task.Delay(1000).Wait();
+        }
+
+        private void CloseOOBE()
+        {
+            try
+            {
+                // Find the close button and click it
+                this.Session.CloseMainWindow();
+                Task.Delay(1000).Wait();
+            }
+            catch (Exception ex)
+            {
+                Assert.Fail($"Failed to close OOBE: {ex.Message}");
+            }
+        }
+
+        private void OpenOOBEFromSettings()
+        {
+            try
+            {
+                // Open PowerToys Settings
+                this.Session.Attach(PowerToysModule.PowerToysSettings);
+
+                // Navigate to General page
+                this.Find<NavigationViewItem>("General").Click();
+                Task.Delay(1000).Wait();
+
+                // Click on "Welcome to PowerToys" link
+                this.Find<HyperlinkButton>("Welcome to PowerToys").Click();
+                Task.Delay(2000).Wait();
+
+                // Verify OOBE opened
+                Assert.IsTrue(this.Session.HasOne("Welcome to PowerToys"), "OOBE should open when clicking the link in Settings");
+
+                // Close OOBE
+                this.Session.CloseMainWindow();
+            }
+            catch (Exception ex)
+            {
+                Assert.Fail($"Failed to open OOBE from Settings: {ex.Message}");
+            }
+        }
+
+        private void ModifyLastVersionFile()
+        {
+            try
+            {
+                // Create PowerToys folder if it doesn't exist
+                string powerToysFolder = Environment.ExpandEnvironmentVariables(LocalAppDataFolderPath);
+                if (!Directory.Exists(powerToysFolder))
+                {
+                    Directory.CreateDirectory(powerToysFolder);
+                }
+
+                // Write a different version to trigger What's New
+                string versionFilePath = Environment.ExpandEnvironmentVariables(LastVersionFilePath);
+                File.WriteAllText(versionFilePath, "0.0.1");
+
+                // Wait to ensure file is written
+                Task.Delay(1000).Wait();
+            }
+            catch (Exception ex)
+            {
+                Assert.Inconclusive($"Could not modify version file: {ex.Message}");
+            }
+        }
+
+        private void StartPowerToysAndVerifyWhatsNewOpens()
+        {
+            try
+            {
+                // Start PowerToys
+                this.RestartScopeExe();
+
+                // Wait for OOBE window to appear
+                Task.Delay(5000).Wait();
+
+                // Verify OOBE window opened
+                Assert.IsTrue(this.Session.HasOne("Welcome to PowerToys"), "OOBE window should open");
+
+                // Verify we're on the What's New page
+                Assert.IsTrue(this.Has("What's new"), "OOBE should open on What's New page after version change");
+            }
+            catch (Exception ex)
+            {
+                Assert.Fail($"Failed to verify What's New page: {ex.Message}");
+            }
+        }
+    }
+}

src/settings-ui/UITest-Settings/SettingsTests.cs

@@ -0,0 +1,149 @@
+// 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.IO;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+using Microsoft.PowerToys.UITest;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Windows.Devices.PointOfService.Provider;
+
+namespace Microsoft.Settings.UITests
+{
+    [TestClass]
+    public class SettingsTests : UITestBase
+    {
+        private readonly string[] dashboardModuleList =
+        {
+            "Advanced Paste",
+            "Always On Top",
+            "Awake",
+            "Color Picker",
+            "Command Palette",
+            "Environment Variables",
+            "FancyZones",
+            "File Locksmith",
+            "Find My Mouse",
+            "Hosts File Editor",
+            "Image Resizer",
+            "Keyboard Manager",
+            "Mouse Highlighter",
+            "Mouse Jump",
+            "Mouse Pointer Crosshairs",
+            "Mouse Without Borders",
+            "New+",
+            "Peek",
+            "PowerRename",
+            "PowerToys Run",
+            "Quick Accent",
+            "Registry Preview",
+            "Screen Ruler",
+            "Shortcut Guide",
+            "Text Extractor",
+            "Workspaces",
+            "ZoomIt",
+
+            // "Crop And Lock", // this module cannot be found, why?
+        };
+
+        private readonly string[] moduleProcess =
+        {
+            "PowerToys.AdvancedPaste",
+            "PowerToys.Run",
+            "PowerToys.AlwaysOnTop",
+            "PowerToys.Awake",
+            "PowerToys.ColorPickerUI",
+            "PowerToys.Peek.UI",
+        };
+
+        public SettingsTests()
+            : base(PowerToysModule.PowerToysSettings, size: WindowSize.Large)
+        {
+        }
+
+        [TestMethod("PowerToys.Settings.ModulesOnAndOffTest")]
+        [TestCategory("Settings Test #1")]
+        public void TestAllmoduleOnAndOff()
+        {
+            DisableAllModules();
+            Task.Delay(2000).Wait();
+
+            // module process won't be killed in debug mode settings UI!
+            // Assert.IsTrue(CheckModulesDisabled(), "Some modules are not disabled.");
+            EnableAllModules();
+            Task.Delay(2000).Wait();
+
+            // Assert.IsTrue(CheckModulesEnabled(), "Some modules are not Enabled.");
+        }
+
+        private void DisableAllModules()
+        {
+            Find<NavigationViewItem>("Dashboard").Click();
+
+            foreach (var moduleName in dashboardModuleList)
+            {
+                var moduleButton = Find<Button>(moduleName);
+                Assert.IsNotNull(moduleButton);
+                var toggle = moduleButton.Find<ToggleSwitch>("Enable module");
+                Assert.IsNotNull(toggle);
+                if (toggle.IsOn)
+                {
+                    toggle.Click();
+                }
+            }
+        }
+
+        private void EnableAllModules()
+        {
+            Find<NavigationViewItem>("Dashboard").Click();
+
+            foreach (var moduleName in dashboardModuleList)
+            {
+                // Scroll(direction: "Down");
+                var moduleButton = Find<Button>(moduleName);
+                Assert.IsNotNull(moduleButton);
+                var toggle = moduleButton.Find<ToggleSwitch>("Enable module");
+                Assert.IsNotNull(toggle);
+                if (!toggle.IsOn)
+                {
+                    toggle.Click();
+                }
+            }
+        }
+
+        private bool CheckModulesDisabled()
+        {
+            Process[] runningProcesses = Process.GetProcesses();
+
+            foreach (var process in moduleProcess)
+            {
+                if (runningProcesses.Any(p => p.ProcessName.Equals(process, StringComparison.OrdinalIgnoreCase)))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        private bool CheckModulesEnabled()
+        {
+            Process[] runningProcesses = Process.GetProcesses();
+
+            foreach (var process in moduleProcess)
+            {
+                if (!runningProcesses.Any(p => p.ProcessName.Equals(process, StringComparison.OrdinalIgnoreCase)))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    }
+}

src/settings-ui/UITest-Settings/SettingsTests.md

@@ -0,0 +1,41 @@
+## [General Settings](tests-checklist-template-settings-section.md)
+
+**Admin mode:**
+ - [] restart PT and verify it runs as user
+ - [] restart as admin and set "Always run as admin"
+ - [] restart PT and verify it  runs as admin
+ * if it's not on, turn on "Run at startup"
+ - [] reboot the machine and verify PT runs as admin (it should not prompt the UAC dialog)
+ * turn Always run as admin" off
+ - [] reboot the machine and verify it now runs as user
+
+**Modules on/off:**
+ - [x] turn off all the modules and verify all module are off
+ - [] restart PT and verify that all module are still off in the settings page and they are actually inactive
+ - [x] turn on all the module, all module are now working
+ - [] restart PT and verify that all module are still on in the settings page and they are actually working
+
+**Quick access tray icon flyout:**
+ - [] Use left click on the system tray icon and verify the flyout appears. (It'll take a bit the first time)
+ - [] Try to launch a module from the launch screen in the flyout.
+ - [] Try disabling a module in the all apps screen in the flyout, make it a module that's launchable from the launch screen. Verify that the module is disabled and that it also disappeared from the launch screen in the flyout.
+ - [] Open the main settings screen on a module page. Verify that when you disable/enable the module on the flyout, that the Settings page is updated too.
+
+**Settings backup/restore:**
+ - [] In the General tab, create a backup of the settings.
+ - [] Change some settings in some PowerToys.
+ - [] Restore the settings in the General tab and verify the Settings you've applied were reset.
+
+## OOBE
+ * Quit PowerToys
+ * Delete %localappdata%\Microsoft\PowerToys
+ - [] Start PowerToys and verify OOBE opens
+ * Change version saved on `%localappdata%\Microsoft\PowerToys\last_version.txt`
+ - [] Start PowerToys and verify OOBE opens in the "What's New" page
+ * Visit each OOBE section and for each section:
+   - [] open the Settings for that module
+   - [] verify the Settings work as expected (toggle some controls on/off etc.)
+   - [] close the Settings
+   - [] if it's available, test the `Launch module name` button
+ * Close OOBE
+ - [x] Open the Settings and from the General page open OOBE using the `Welcome to PowerToys` link

src/settings-ui/UITest-Settings/UITest-Settings.csproj

@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+	<!-- Look at Directory.Build.props in root for common stuff as well -->
+	<Import Project="..\..\Common.Dotnet.CsWinRT.props" />
+
+	<PropertyGroup>
+		<ProjectGuid>{29B91A80-0590-4B1F-89B8-4F8812A7F116}</ProjectGuid>
+		<RootNamespace>Microsoft.Settings.UITests</RootNamespace>
+		<IsPackable>false</IsPackable>
+		<Nullable>enable</Nullable>
+		<OutputType>Library</OutputType>
+
+		<!-- This is a UI test, so don't run as part of MSBuild -->
+		<RunVSTest>false</RunVSTest>
+	</PropertyGroup>
+
+	<PropertyGroup>
+		<OutputPath>..\..\..\$(Platform)\$(Configuration)\tests\UITests-Settings\</OutputPath>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="Appium.WebDriver" />
+		<PackageReference Include="MSTest" />
+		<PackageReference Include="System.Net.Http" />
+		<PackageReference Include="System.Private.Uri" />
+		<PackageReference Include="System.Text.RegularExpressions" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<ProjectReference Include="..\..\common\UITestAutomation\UITestAutomation.csproj" />
+	</ItemGroup>
+
+</Project>