diff --git a/.github/workflows/tests-outerloop.yml b/.github/workflows/tests-outerloop.yml
index 8aa81ffa506..b414a07ee90 100644
--- a/.github/workflows/tests-outerloop.yml
+++ b/.github/workflows/tests-outerloop.yml
@@ -12,88 +12,60 @@ concurrency:
 
 jobs:
 
-  test:
-    name: ${{ matrix.os.title }}
-    runs-on: ${{ matrix.os.name }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os:
-          - name: ubuntu-latest
-            title: Linux
-          - name: windows-latest
-            title: Windows
+  generate_tests_matrix:
+    name: Generate test runsheet
+    runs-on: windows-latest
+    if: ${{ github.repository_owner == 'dotnet' }}
+    outputs:
+      runsheet: ${{ steps.generate_tests_matrix.outputs.runsheet }}
     steps:
-      - name: Setup vars (Linux)
-        if: ${{ matrix.os.name == 'ubuntu-latest' }}
-        run: |
-          echo "DOTNET_SCRIPT=./dotnet.sh" >> $GITHUB_ENV
-          echo "BUILD_SCRIPT=./build.sh" >> $GITHUB_ENV
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
 
-      - name: Setup vars (Windows)
-        if: ${{ matrix.os.name == 'windows-latest' }}
+      # We need to build the whole solution, so that we can interrogate each test project
+      # and find out whether it contains any quarantined tests.
+      - name: Build the solution
         run: |
-          echo "DOTNET_SCRIPT=.\dotnet.cmd" >> $env:GITHUB_ENV
-          echo "BUILD_SCRIPT=.\build.cmd" >> $env:GITHUB_ENV
+          ./build.cmd -restore -build -c Release -ci /p:CI=false /p:GeneratePackageOnBuild=false /p:InstallBrowsersForPlaywright=false
 
-      - name: Checkout code
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-
-      - name: Trust HTTPS development certificate (Linux)
-        if: matrix.os.name == 'ubuntu-latest'
-        run: ${{ env.DOTNET_SCRIPT }} dev-certs https --trust
-
-      - name: Run quarantined tests
-        env:
-          CI: false
+      - name: Generate test runsheet
+        id: generate_tests_matrix
         run: |
-          ${{ env.BUILD_SCRIPT }} -projects ${{ github.workspace }}/tests/Shared/SolutionTests.proj -ci -restore -build -test -c Release /p:RunQuarantinedTests=true /bl:${{ github.workspace }}/artifacts/log/Release/test-quarantined.binlog
+          ./build.cmd -test /p:TestRunnerName=QuarantinedTestRunsheetBuilder /p:RunQuarantinedTests=true -c Release -ci /p:CI=false /p:Restore=false /p:Build=false /bl:./artifacts/log/Release/runsheet.binlog
 
-      - name: Keep only relevant test logs
-        if: always()
-        shell: pwsh
-        run: |
-          # Define the directory to search for log files
-          $logDirectory = "${{ github.workspace }}/artifacts/log/**/TestLogs"
+      - name: Upload logs, and test results
+        if: ${{ always() }}
+        uses: actions/upload-artifact@4cec3d8aa04e39d1a68397de0c4cd6fb9dce8ec1 # v4.6.1
+        with:
+          name: logs-runsheet
+          path: |
+            ${{ github.workspace }}/artifacts/log/*/*.binlog
+            ${{ github.workspace }}/artifacts/log/*/TestLogs/**
+            ${{ github.workspace }}/artifacts/tmp/*/combined_runsheet.json
+          retention-days: 5
 
-          # Define the text to search for in the log files
-          $searchText = "No test matches the given testcase filter"
-          $resultsFilePattern = "Results File: (.+)"
+  run_tests:
+    name: Test
+    needs: generate_tests_matrix
+    strategy:
+      fail-fast: false
+      matrix:
+        tests: ${{ fromJson(needs.generate_tests_matrix.outputs.runsheet) }}
 
-          # Get all .log files in the specified directory and its subdirectories
-          $logFiles = Get-ChildItem -Path $logDirectory -Filter *.log -Recurse
+    runs-on: ${{ matrix.tests.os }} # Use the OS from the matrix
+    if: ${{ github.repository_owner == 'dotnet' }}
 
-          foreach ($logFile in $logFiles) {
-              # Read the content of the log file
-              $content = Get-Content -Path $logFile.FullName
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
 
-              # Check if the content contains the specified text
-              if ($content -match $searchText) {
-                  # Remove the log file if it contains the specified text
-                  Remove-Item -Path $logFile.FullName -Force
-                  Write-Host "Removed file: $($logFile.FullName)"
-              }
-              else {
-                  # Extract paths from lines containing "Results File: <path>"
-                  foreach ($line in $content) {
-                      if ($line -match $resultsFilePattern) {
-                          $resultsFilePath = $matches[1]
-                          Write-Host "Found results file: $resultsFilePath"
-
-                          # Copy the results file to the TestLogs folder
-                          $destinationPath = (Split-Path -Path $logFile.FullName -Parent)
-                          Copy-Item -Path $resultsFilePath -Destination $destinationPath -Force
-                          Write-Host "Copied $resultsFilePath to $destinationPath"
-                      }
-                  }
-              }
-          }
+      - name: Test ${{ matrix.tests.project }}
+        run: |
+          ${{ matrix.tests.command }}
 
       - name: Process logs and post results
         if: always()
         shell: pwsh
         run: |
-          $logDirectory = "${{ github.workspace }}/artifacts/log/**/TestLogs"
+          $logDirectory = "${{ github.workspace }}/artifacts/TestResults"
           $trxFiles = Get-ChildItem -Path $logDirectory -Filter *.trx -Recurse
 
           $testResults = @() # Initialize an array to store test results
@@ -157,19 +129,13 @@ jobs:
           $table | Out-File -FilePath $outputPath -Encoding utf8
           Write-Host "Test results saved to $outputPath"
 
-          # Windows-specific: Check for failed tests and set the exit code accordingly
-          # This is a workaround for the issue with the `exit` command in PowerShell
-          if ($failedTests -gt 0) {
-              Write-Host "::error::Build failed. Check errors above."
-              exit 1
-          }
-
       - name: Upload logs, and test results
-        if: always()
+        if: failure()
         uses: actions/upload-artifact@4cec3d8aa04e39d1a68397de0c4cd6fb9dce8ec1 # v4.6.1
         with:
-          name: logs-${{ matrix.os.name }}
+          name: logs-${{ matrix.tests.os }}-${{ matrix.tests.project }}
           path: |
             ${{ github.workspace }}/artifacts/log/*/*.binlog
             ${{ github.workspace }}/artifacts/log/*/TestLogs/**
+            ${{ github.workspace }}/artifacts/TestResults/*/*.trx
           retention-days: 5
diff --git a/eng/AfterSolutionBuild.targets b/eng/AfterSolutionBuild.targets
new file mode 100644
index 00000000000..cadc5b7fbf3
--- /dev/null
+++ b/eng/AfterSolutionBuild.targets
@@ -0,0 +1,90 @@
+<Project>
+
+  <!--
+    In short, this file automates the creation of a combined JSON runsheet from individual test runsheets,
+    making it easy to integrate quarantined test execution into CI workflows, especially GitHub Actions.
+   -->
+
+  <!--
+    This MSBuild targets file automates the generation of a combined test runsheet after building a solution,
+    using the QuarantinedTestRunsheetBuilder (located in eng/QuarantinedTestRunsheetBuilder/QuarantinedTestRunsheetBuilder.targets).
+
+    Here's a high-level overview of its logic:
+
+    1. **Conditionally Triggered Target**:
+      - The target _GenerateTestMatrix runs before the Test target, but only if the TestRunnerName property is set to QuarantinedTestRunsheetBuilder.
+
+    2. **Define Paths and Script Content**:
+      - Defines a combined runsheet JSON file path (_CombinedRunsheetFile) in the artifacts temporary directory.
+      - Defines a PowerShell script (_Command) that:
+        - Finds all individual .runsheet.json files in the artifacts directory.
+        - Reads and merges their JSON content into a single combined JSON array.
+        - Writes the combined JSON to the combined runsheet file.
+        - Checks if running in GitHub Actions environment:
+          - If yes, outputs the combined JSON to GitHub Actions output (GITHUB_OUTPUT).
+          - If no, prints the combined JSON to the console.
+
+    3. **Write and Execute the Script**:
+      - Writes the defined PowerShell script content to a temporary script file (create-runsheet.ps1).
+      - Executes this script using MSBuild's <Exec> task.
+
+    4. **Output Results**:
+      - After execution, logs a message indicating the combined runsheet was created, along with the script's output.
+
+    A runsheet is a JSON file that describes what tests to be run.
+    For example:
+
+      ```json
+      [
+        {
+          "project": "Aspire.Test",
+          "os": "windows-latest",
+          "command": "./eng/build.ps1 -restore -build -test -projects \"$(RelativeTestProjectPath)\" /bl:\"$(RelativeTestBinLog)\" -c $(Configuration) -ci /p:RunQuarantinedTests=true /p:CI=false"
+        },
+        {
+          "project": "Aspire.Cli.Test",
+          "os": "ubuntu-latest",
+          "command": "./eng/build.sh -restore -build -test -projects \"$(RelativeTestProjectPath)\" /bl:\"$(RelativeTestBinLog)\" -c $(Configuration) -ci /p:RunQuarantinedTests=true /p:CI=false"
+        }
+      ]
+      ```
+
+    -->
+  <Target Name="_GenerateTestMatrix" BeforeTargets="Test" Condition=" '$(TestRunnerName)' == 'QuarantinedTestRunsheetBuilder' ">
+    <PropertyGroup>
+      <_CombinedRunsheetFile>$(ArtifactsTmpDir)/combined_runsheet.json</_CombinedRunsheetFile>
+      <_Command>
+        $combined = @()
+        Get-ChildItem -Path '$(ArtifactsTmpDir)' -Filter '*.runsheet.json' |
+            ForEach-Object {
+                $content = Get-Content -Raw $_.FullName | ConvertFrom-Json
+                if ($content -is [Array]) {
+                    $combined += $content
+                }
+                else {
+                    $combined += @($content)
+                }
+            }
+        $jsonString = ($combined | ConvertTo-Json -Depth 10 -Compress)
+        $jsonString | Set-Content '$(_CombinedRunsheetFile)';
+
+        # determine if the script is running in a GitHub Actions environment
+        if ($env:CI -and $env:GITHUB_ACTIONS) {
+            "runsheet=$jsonString" | Out-File -FilePath $env:GITHUB_OUTPUT -Encoding utf8 -Append
+        }
+        else {
+            Write-Host "runsheet=$jsonString"
+        }
+      </_Command>
+      <_Script>$([MSBuild]::NormalizePath($(ArtifactsTmpDir), 'create-runsheet.ps1'))</_Script>
+    </PropertyGroup>
+
+    <WriteLinesToFile File="$(_Script)"
+                      Lines="$(_Command)"
+                      Overwrite="true" />
+    <Exec Command="pwsh -File $(_Script)" ConsoleToMSBuild="true">
+      <Output TaskParameter="ConsoleOutput" PropertyName="ScriptOutput" />
+    </Exec>
+    <Message Importance="high" Text="Combined runsheet created%0D%0A%0D%0A$(ScriptOutput)" />
+  </Target>
+</Project>
diff --git a/eng/QuarantinedTestRunsheetBuilder/QuarantinedTestRunsheetBuilder.targets b/eng/QuarantinedTestRunsheetBuilder/QuarantinedTestRunsheetBuilder.targets
new file mode 100644
index 00000000000..d464a433c2d
--- /dev/null
+++ b/eng/QuarantinedTestRunsheetBuilder/QuarantinedTestRunsheetBuilder.targets
@@ -0,0 +1,171 @@
+<Project>
+  <!--
+
+    This file is used to generate a list of tests to run on GitHub Actions.
+
+         .\build.cmd -test /p:TestRunnerName=QuarantinedTestRunsheetBuilder /p:RunQuarantinedTests=true [/bl /p:GITHUB_ACTIONS=true]
+
+    For the large part this is a copy of the Arcade SDK's implementations:
+      - https://github.com/dotnet/arcade/blob/b888df17/src/Microsoft.DotNet.Arcade.Sdk/tools/XUnit/XUnit.Runner.targets
+      - https://github.com/dotnet/arcade/blob/b888df17/src/Microsoft.DotNet.Arcade.Sdk/tools/VSTest.targets
+   -->
+
+  <!--
+    In short, this file automates the detection of quarantined tests and generates appropriate GitHub Actions runsheets to execute these tests separately,
+    ensuring quarantined tests are handled explicitly and systematically.
+
+    This MSBuild targets file automates the detection and handling of quarantined tests within a .NET project's CI pipeline.
+    Here's a high-level overview of its logic:
+
+    1. **Run Tests and Capture Output**:
+      - Executes test assemblies using the configured test runner.
+      - Captures the output into a log file (`ResultsStdOutPath`).
+
+    2. **Check for Errors**:
+      - If the test runner exits with a non-zero exit code (`_TestErrorCode`), it triggers an MSBuild `<Error>` task, indicating the test search failed.
+
+    3. **Detect Quarantined Tests**:
+      - Reads the captured test output log file.
+      - Checks if the log contains the phrase `"No test matches the given testcase filter"`. If found, it means there are no quarantined tests.
+
+    4. **Set Flags Based on Detection**:
+      - Sets a property `_HasQuarantinedTests` to `true` or `false` based on the presence or absence of quarantined tests.
+
+    5. **Generate Test Runsheets**:
+      - If quarantined tests are detected (`_HasQuarantinedTests` is `true`), it constructs JSON-formatted "runsheet" files for GitHub Actions.
+        These runsheets contain commands to execute quarantined tests specifically on Windows (`build.ps1`) or Linux (`build.sh`).
+        For example:
+
+          ```json
+          {
+            "project": "Aspire.Test",
+            "os": "windows-latest",
+            "command": "./eng/build.ps1 -restore -build -test -projects \"$(RelativeTestProjectPath)\" /bl:\"$(RelativeTestBinLog)\" -c $(Configuration) -ci /p:RunQuarantinedTests=true /p:CI=false"
+          }
+          ```
+
+    6. **Write Runsheets to Files**:
+      - Writes the generated JSON runsheets to the artifacts directory, separately for Windows and Linux environments, conditioned on the environment
+        variables (`RunOnGithubActionsWindows`, `RunOnGithubActionsLinux`).
+
+    NOTE: The final piece of the puzzle is in eng/AfterSolutionBuild.targets, where we combine the runsheets from all the test projects into a single runsheet.
+
+    -->
+  <Target Name="RunTests"
+          Outputs="%(TestToRun.ResultsStdOutPath)"
+          Condition=" '$(SkipTests)' != 'true' and '$(IsGitHubActionsRunner)' == 'true' and '$(RunOnGithubActions)' == 'true' ">
+
+    <PropertyGroup>
+      <_TestEnvironment>%(TestToRun.EnvironmentDisplay)</_TestEnvironment>
+      <_TestAssembly>%(TestToRun.Identity)</_TestAssembly>
+      <_TestAssembly Condition="'$(OS)'=='Windows_NT'">$([System.IO.Path]::ChangeExtension($(_TestAssembly), '.exe'))</_TestAssembly>
+      <_TestAssembly Condition="'$(OS)'!='Windows_NT'">$(_TestAssembly.TrimEnd('.dll'))</_TestAssembly>
+      <_TestTimeout>%(TestToRun.TestTimeout)</_TestTimeout>
+
+      <_TargetDir>$([System.IO.Path]::GetDirectoryName('$(_TestAssembly)'))\</_TargetDir>
+
+      <_TestRunnerCommand>$(_TestAssembly) --list-tests $(_QuarantinedTestRunAdditionalArgs)</_TestRunnerCommand>
+
+      <!--
+        Redirect std output of the runner.
+        -->
+      <_TestRunnerCommand Condition="'$(TestCaptureOutput)' != 'false'">$(_TestRunnerCommand) >> "%(TestToRun.ResultsStdOutPath)" 2>&amp;1</_TestRunnerCommand>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <_OutputFiles Include="%(TestToRun.ResultsStdOutPath)" />
+    </ItemGroup>
+
+    <MakeDir Directories="@(_OutputFiles->'%(RootDir)%(Directory)')"/>
+    <Delete Files="@(_OutputFiles)" />
+
+    <!--
+      Add command line to the log.
+      -->
+    <Exec Command="echo === COMMAND LINE === > %(TestToRun.ResultsStdOutPath)
+                   echo $(_TestRunnerCommand) >> %(TestToRun.ResultsStdOutPath)" />
+
+    <Message Text="Searching for quarantined tests: $(_TestAssembly) [$(_TestEnvironment)]" Importance="high"/>
+    <Exec Command='$(_TestRunnerCommand)'
+          LogStandardErrorAsError="false"
+          WorkingDirectory="$(_TargetDir)"
+          IgnoreExitCode="true"
+          Timeout="$(_TestTimeout)"
+          EnvironmentVariables="DOTNET_ROOT=$(DotNetRoot);DOTNET_ROOT_X86=$(DotNetRoot)x86"
+          ContinueOnError="WarnAndContinue">
+      <Output TaskParameter="ExitCode" PropertyName="_TestErrorCode" />
+    </Exec>
+
+    <PropertyGroup>
+      <_ResultsFileToDisplay>%(TestToRun.ResultsStdOutPath)</_ResultsFileToDisplay>
+    </PropertyGroup>
+
+    <!--
+      Report test status.
+      -->
+    <Message Text="Search complete, no quarantined tests found: $(_TestAssembly) [$(_TestEnvironment)]" Condition="'$(_TestErrorCode)' == '8'" Importance="high" />
+    <Message Text="💡 Search complete, quarantined tests found: $(_TestAssembly) [$(_TestEnvironment)]" Condition="'$(_TestErrorCode)' == '0'" Importance="high" />
+    <Error Text="Search failed: $(_ResultsFileToDisplay) [$(_TestEnvironment)]" Condition=" '$(_TestErrorCode)' != '0' and '$(_TestErrorCode)' != '8' " File="QuarantinedTestRunsheetBuilder" />
+
+    <PropertyGroup>
+      <_HasQuarantinedTests>true</_HasQuarantinedTests>
+      <_HasQuarantinedTests Condition=" '$(_TestErrorCode)' == '8' ">false</_HasQuarantinedTests>
+    </PropertyGroup>
+
+    <!--
+      Generate test runsheet, if there are quarantined tests.
+      -->
+    <PropertyGroup Condition=" '$(_HasQuarantinedTests)' == 'true' ">
+      <!--
+        We do not care whether the project is multi-targeting, we're only generating a command to kick off the testing sequence,
+        which in turn will run the tests for all the target frameworks.
+
+        So, instead of using "%(TestToRun.ResultsFilePathWithoutExtension)" (which looks something like "Aspire.Cli.Tests_net8.0_x64")
+        we use the project name (which looks something like "Aspire.Cli.Tests").
+        -->
+      <_TestRunsheet>$(MSBuildProjectName)</_TestRunsheet>
+      <_TestBinLog>$([MSBuild]::NormalizePath($(ArtifactsLogDir), '$(_TestRunsheet).binlog'))</_TestBinLog>
+
+      <_RelativeTestProjectPath>$([System.String]::Copy('$(MSBuildProjectFullPath)').Replace('$(RepoRoot)', '%24(pwd)/'))</_RelativeTestProjectPath>
+      <_RelativeTestBinLog>$([System.String]::Copy('$(_TestBinLog)').Replace('$(RepoRoot)', '%24(pwd)/'))</_RelativeTestBinLog>
+
+      <_TestRunnerWindows>./eng/build.ps1</_TestRunnerWindows>
+      <_TestRunnerLinux>./eng/build.sh</_TestRunnerLinux>
+      <_TestCommand>-restore -build -test -projects &quot;$(_RelativeTestProjectPath)&quot; /bl:&quot;$(_RelativeTestBinLog)&quot; -c $(Configuration) -ci /p:RunQuarantinedTests=true /p:CI=false</_TestCommand>
+
+      <!-- Replace \ with /, and then escape " with \", so we have a compliant JSON -->
+      <_TestCommand>$([System.String]::Copy($(_TestCommand)).Replace("\", "/").Replace('&quot;', '\&quot;'))</_TestCommand>
+
+      <_TestRunsheetWindows>{ "project": "$(_TestRunsheet)", "os": "windows-latest", "command": "./eng/build.ps1 $(_TestCommand)" }</_TestRunsheetWindows>
+      <_TestRunsheetLinux>{ "project": "$(_TestRunsheet)", "os": "ubuntu-latest", "command": "./eng/build.sh $(_TestCommand)" }</_TestRunsheetLinux>
+    </PropertyGroup>
+
+    <WriteLinesToFile
+            Condition=" '$(RunOnGithubActionsWindows)' == 'true' and  '$(_HasQuarantinedTests)' == 'true'"
+            File="$(ArtifactsTmpDir)/$(_TestRunsheet).win.runsheet.json"
+            Lines="$(_TestRunsheetWindows)"
+            Overwrite="true"
+            WriteOnlyWhenDifferent="true" />
+
+    <WriteLinesToFile
+            Condition=" '$(RunOnGithubActionsLinux)' == 'true' and '$(_HasQuarantinedTests)' == 'true' "
+            File="$(ArtifactsTmpDir)/$(_TestRunsheet).linux.runsheet.json"
+            Lines="$(_TestRunsheetLinux)"
+            Overwrite="true"
+            WriteOnlyWhenDifferent="true" />
+
+    <!--
+      On Linux there's a bug in MSBuild, which "normalises" all slashes (see https://github.com/dotnet/msbuild/issues/3468).
+      This is a workaround to replace `/"` with the required `\"`.
+      -->
+    <Exec Command="pwsh -Command &quot;(Get-Content -Path '$(ArtifactsTmpDir)/$(_TestRunsheet).win.runsheet.json') -replace '/\&quot;', '\\\&quot;' | Set-Content -Path '$(ArtifactsTmpDir)/$(_TestRunsheet).win.runsheet.json'&quot; "
+          Condition=" '$(RunOnGithubActionsWindows)' == 'true' and '$(_HasQuarantinedTests)' == 'true' and '$(BuildOs)' != 'windows' " />
+    <Exec Command="pwsh -Command &quot;(Get-Content -Path '$(ArtifactsTmpDir)/$(_TestRunsheet).linux.runsheet.json') -replace '/\&quot;', '\\\&quot;' | Set-Content -Path '$(ArtifactsTmpDir)/$(_TestRunsheet).linux.runsheet.json'&quot; "
+          Condition=" '$(RunOnGithubActionsLinux)' == 'true' and '$(_HasQuarantinedTests)' == 'true' and '$(BuildOs)' != 'windows' " />
+
+    <!--
+      The final piece of the puzzle is in eng/AfterSolutionBuild.targets, where we combine the runsheets from all the test projects into a single runsheet.
+      -->
+  </Target>
+
+</Project>
diff --git a/tests/Aspire.Templates.Tests/Aspire.Templates.Tests.csproj b/tests/Aspire.Templates.Tests/Aspire.Templates.Tests.csproj
index 78faf4d9376..9fdc76892f8 100644
--- a/tests/Aspire.Templates.Tests/Aspire.Templates.Tests.csproj
+++ b/tests/Aspire.Templates.Tests/Aspire.Templates.Tests.csproj
@@ -24,6 +24,9 @@
       gets built independently on helix.
     -->
     <NoWarn>$(NoWarn);xUnit1051</NoWarn>
+
+    <!-- FIXME: do not run Template tests in the outerloop until further notice -->
+    <SkipTests Condition=" '$(RunQuarantinedTests)' == 'true' ">true</SkipTests>
   </PropertyGroup>
 
   <Import Project="..\Shared\TemplatesTesting\Aspire.Shared.TemplatesTesting.targets" />
diff --git a/tests/Shared/SolutionTests.proj b/tests/Shared/SolutionTests.proj
deleted file mode 100644
index 15d49df2396..00000000000
--- a/tests/Shared/SolutionTests.proj
+++ /dev/null
@@ -1,30 +0,0 @@
-<Project Sdk="Microsoft.Build.Traversal">
-  <!--
-    This file is used to build all the eligible test projects in the repo.
-    It is used to execute the tests in the outer loop and in the CI pipeline.
-
-    Generally, this project should invoked in the following way:
-
-      ./build.cmd -projects ./tests/Shared/SolutionTests.proj -restore -build -test /p:RunQuarantinedTests=[true|false]
-
-   -->
-  <PropertyGroup>
-    <TargetFramework>$(DefaultTargetFramework)</TargetFramework>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <_TestProjectsToExclude Include="$(RepoRoot)tests\Shared\**\*Tests.csproj" />
-    <_TestProjectsToExclude Include="$(RepoRoot)tests\testproject\**\*Tests.csproj" />
-    <_TestProjectsToExclude Include="$(RepoRoot)tests\TestingAppHost1\**\*Tests.csproj" />
-
-    <!-- This runs in a separate job -->
-    <_TestProjectsToExclude Include="$(RepoRoot)tests\Aspire.Templates.Tests\**\*Tests.csproj" />
-
-    <_TestProjectsToInclude Include="$(RepoRoot)tests\**\*Tests.csproj" />
-
-    <!-- Add all the test projects we want to build as project references, so the traversal SDK can build them -->
-    <ProjectReference Include="@(_TestProjectsToInclude)"
-                      Exclude="@(_TestProjectsToExclude)" />
-  </ItemGroup>
-
-</Project>