You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by pa...@apache.org on 2026/10/15 17:06:18 UTC

(lucenenet) branch master updated: Publish ADO test results from the test step instead of per-project tasks (#1446)

This is an automated email from the ASF dual-hosted git repository.

paulirwin pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git


The following commit(s) were added to refs/heads/master by this push:
     new ec7c12d7a Publish ADO test results from the test step instead of per-project tasks (#1446)
ec7c12d7a is described below

commit ec7c12d7ab797901b723145c6b393a4343cd3e6d
Author: Paul Irwin <pa...@gmail.com>
AuthorDate: Thu Oct 15 11:06:12 2026 -0600

    Publish ADO test results from the test step instead of per-project tasks (#1446)
    
    Co-authored-by: Claude Fable 5.1 <no...@anthropic.com>
---
 .../publish-test-results-for-test-projects.yml     | 487 ---------------------
 .build/azure-templates/publish-test-results.yml    | 146 ------
 .build/azure-templates/run-tests-on-os.yml         | 187 +++++++-
 3 files changed, 174 insertions(+), 646 deletions(-)

diff --git a/.build/azure-templates/publish-test-results-for-test-projects.yml b/.build/azure-templates/publish-test-results-for-test-projects.yml
deleted file mode 100644
index 3fb603eb6..000000000
--- a/.build/azure-templates/publish-test-results-for-test-projects.yml
+++ /dev/null
@@ -1,487 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,-with-title
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-# Runs Publish Test Results task for all Lucene.Net test projects
-
-# The tasks can be easily re-generated (except for any special cases) using the following PowerShell script
-
-#$source_directory = "F:/Projects/lucenenet" # Change to your repo location
-#
-#$testProjects = Get-ChildItem -Path "$source_directory/**/*.csproj" -Recurse | ? { $_.Directory.Name.Contains(".Tests") } | Sort-Object -Property FullName
-#
-#[string]$output = ''
-#
-#foreach ($testProject in $testProjects) {
-#    $projectName = [System.IO.Path]::GetFileNameWithoutExtension($testProject)
-#
-#    $block = `
-#        "- template: publish-test-results.yml`n" + `
-#        "  parameters:`n" + `
-#        "    testProjectName: '$projectName'`n" + `
-#        "    osName: '$`{`{ parameters.osName `}`}'`n" + `
-#        "    framework: '$`{`{ parameters.framework `}`}'`n" + `
-#        "    vsTestPlatform: '$`{`{ parameters.vsTestPlatform `}`}'`n" + `
-#        "    testResultsFormat: '$`{`{ parameters.testResultsFormat `}`}'`n" + `
-#        "    testResultsArtifactName: '$`{`{ parameters.testResultsArtifactName `}`}'`n" + `
-#        "    testResultsFileName: '$`{`{ parameters.testResultsFileName `}`}'`n" + `
-#        "`n"
-#
-#    $output = "$output$block"
-#}
-#
-#Set-Clipboard -Value $output
-
-parameters:
-  osName: '' # The name of the operating system for display purposes.
-  framework: '' # The target framework to publish.
-  vsTestPlatform: 'x64' # Target platform architecture used for test execution. Valid values are x86, x64, and ARM.
-  testResultsFormat: VSTest # Specify the format of the results files you want to publish. The following formats are supported: JUnit, NUnit, VSTest, XUnit, CTest
-  testResultsArtifactName: 'testresults' # The name of the Azure DevOps build artifact where the test results will be published. Default 'testresults'.
-  testResultsFileName: 'TestResults.trx' # The name of the file (not path) of the test results. Default 'TestResults.trx'.
-
-steps:
-#- pwsh: |
-#    function EnsureNotNullOrEmpty([string]$param, [string]$nameOfParam) {
-#        if ([string]::IsNullOrEmpty($param)) {
-#            Write-Host "##vso[task.logissue type=error;]Missing template parameter \"$nameOfParam\""
-#            Write-Host "##vso[task.complete result=Failed;]"
-#        }
-#    }
-#    EnsureNotNullOrEmpty('${{ parameters.osName }}', 'osName')
-#    EnsureNotNullOrEmpty('${{ parameters.framework }}', 'framework')
-#    EnsureNotNullOrEmpty('${{ parameters.vsTestPlatform }}', 'vsTestPlatform')
-#    EnsureNotNullOrEmpty('${{ parameters.testResultsFormat }}', 'testResultsFormat')
-#    EnsureNotNullOrEmpty('${{ parameters.testResultsArtifactName }}', 'testResultsArtifactName')
-#    EnsureNotNullOrEmpty('${{ parameters.testResultsFileName }}', 'testResultsFileName')
-#  displayName: 'Validate Template Parameters'
-
-
-# Special case: Only supports .NET Standard 1.3 (we only need to test this on one framework because it is for VS)
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.CodeAnalysis'
-    framework: 'net8.0' # Since conditions are not supported for templates, we check for the file existence within publish-test-results.yml
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    osName: '${{ parameters.osName }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-# Special case: Only supports net10.0, net9.0 and net8.0
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Cli'
-    framework: 'net10.0' # Since conditions are not supported for templates, we check for the file existence within publish-test-results.yml
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    osName: '${{ parameters.osName }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Cli'
-    framework: 'net9.0' # Since conditions are not supported for templates, we check for the file existence within publish-test-results.yml
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    osName: '${{ parameters.osName }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Cli'
-    framework: 'net8.0' # Since conditions are not supported for templates, we check for the file existence within publish-test-results.yml
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    osName: '${{ parameters.osName }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-# Special case: Only supports net10.0, net9.0, net8.0 and net48
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Analysis.OpenNLP'
-    framework: 'net10.0' # Since conditions are not supported for templates, we check for the file existence within publish-test-results.yml
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    osName: '${{ parameters.osName }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Analysis.OpenNLP'
-    framework: 'net9.0' # Since conditions are not supported for templates, we check for the file existence within publish-test-results.yml
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    osName: '${{ parameters.osName }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Analysis.OpenNLP'
-    framework: 'net8.0' # Since conditions are not supported for templates, we check for the file existence within publish-test-results.yml
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    osName: '${{ parameters.osName }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Analysis.OpenNLP'
-    framework: 'net48' # Since conditions are not supported for templates, we check for the file existence within publish-test-results.yml
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    osName: '${{ parameters.osName }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.ICU'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests._A-D'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests._E-I'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests._I-J'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests._J-S'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests._T-Z'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.AllProjects'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Analysis.Common'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Analysis.Kuromoji'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Analysis.Morfologik'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Analysis.Phonetic'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Analysis.SmartCn'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Analysis.Stempel'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Benchmark'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Classification'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Codecs'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Demo'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Expressions'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Facet'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Grouping'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Highlighter'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Join'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Memory'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Misc'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Queries'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.QueryParser'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Replicator'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Sandbox'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Spatial'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.Suggest'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.TestFramework.DependencyInjection'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.TestFramework.NUnitExtensions'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
-
-- template: publish-test-results.yml
-  parameters:
-    testProjectName: 'Lucene.Net.Tests.TestFramework'
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-    testResultsFormat: '${{ parameters.testResultsFormat }}'
-    testResultsArtifactName: '${{ parameters.testResultsArtifactName }}'
-    testResultsFileName: '${{ parameters.testResultsFileName }}'
diff --git a/.build/azure-templates/publish-test-results.yml b/.build/azure-templates/publish-test-results.yml
deleted file mode 100644
index 5db89741c..000000000
--- a/.build/azure-templates/publish-test-results.yml
+++ /dev/null
@@ -1,146 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-# Runs Publish Test Results task for a specific framework
-
-parameters:
-  testProjectName: '' # The name of the test project
-  framework: '' # The target framework for display purposes.
-  vsTestPlatform: 'x64' # Target platform architecture used for test execution. Valid values are x86, x64, and ARM.
-  osName: '' # The name of the operating system for display purposes.
-  testResultsFormat: VSTest # Specify the format of the results files you want to publish. The following formats are supported: JUnit, NUnit, VSTest, XUnit, CTest
-  testResultsArtifactName: 'testresults' # The name of the Azure DevOps build artifact where the test results will be published. Default 'testresults'.
-  testResultsFileName: 'TestResults.trx' # The name of the file (not path) of the test results. Default 'TestResults.trx'.
-
-steps:
-#- pwsh: |
-#    function EnsureNotNullOrEmpty([string]$param, [string]$nameOfParam) {
-#        if ([string]::IsNullOrEmpty($param)) {
-#            Write-Host "##vso[task.logissue type=error;]Missing template parameter \"$nameOfParam\""
-#            Write-Host "##vso[task.complete result=Failed;]"
-#        }
-#    }
-#    EnsureNotNullOrEmpty('${{ parameters.testProjectName }}', 'testProjectName')
-#    EnsureNotNullOrEmpty('${{ parameters.framework }}', 'framework')
-#    EnsureNotNullOrEmpty('${{ parameters.vsTestPlatform }}', 'vsTestPlatform')
-#    EnsureNotNullOrEmpty('${{ parameters.osName }}', 'osName')
-#    EnsureNotNullOrEmpty('${{ parameters.testResultsFormat }}', 'testResultsFormat')
-#    EnsureNotNullOrEmpty('${{ parameters.testResultsArtifactName }}', 'testResultsArtifactName')
-#    EnsureNotNullOrEmpty('${{ parameters.testResultsFileName }}', 'testResultsFileName')
-#  displayName: 'Validate Template Parameters'
-
-#- template: 'show-all-files.yml' # Uncomment for debugging
-
-- pwsh: |
-    $testProjectName = "${{ parameters.testProjectName }}"
-    $testResultsFileName = "$(Build.ArtifactStagingDirectory)/${{ parameters.testResultsArtifactName }}/${{ parameters.osName }}/${{ parameters.framework }}/${{ parameters.vsTestPlatform }}/$testProjectName/${{ parameters.testResultsFileName }}"
-    $testResultsFileExists = Test-Path $testResultsFileName
-    if ($testResultsFileExists) {
-
-        $reader = [System.Xml.XmlReader]::Create($testResultsFileName)
-        try {
-            $countersFound = $false
-            $crashed = $false
-            $inRunInfos = $false
-            while ($reader.Read()) {
-                if ($reader.NodeType -eq [System.Xml.XmlNodeType]::Element) {
-                    if (!$countersFound -and $reader.Name -eq 'Counters') {
-                        $failed = $reader.GetAttribute('failed')
-                        $passed = $reader.GetAttribute('passed')
-                        $ignored = (([int]$reader.GetAttribute('total')) - ([int]$reader.GetAttribute('executed'))).ToString()
-                        $testResults = "Tests failed: $failed, passed: $passed, ignored: $ignored"
-                        Write-Host "##vso[task.setvariable variable=TestResults;]$testResults"
-                        # Report a running total of failures
-                        $totalFailures = ([int]$env:TOTALFAILURES + [int]$failed).ToString()
-                        Write-Host "##vso[task.setvariable variable=TotalFailures;]$totalFailures"
-                        $countersFound = $true
-                    }
-                    # Report a crash of the test runner
-                    if ($reader.Name -eq 'RunInfos') {
-                        $inRunInfos = $true
-                    }
-                    if ($inRunInfos -and !$crashed -and $reader.Name -eq 'Text') {
-                        $innerXml = $reader.ReadInnerXml()
-                        # Test for specific error messages - we may need to adjust this, as needed
-                        if ($innerXml -and ($innerXml.Contains('Test host process crashed') `
-                            -or $innerXml.Contains('Could not load file or assembly') `
-                            -or $innerXml.Contains("Could not find `'dotnet.exe`' host") `
-                            -or $innerXml.Contains('No test is available') `
-                            -or $innerXml.Contains('exited with error'))) {
-                            Write-Host "##vso[task.setvariable variable=HostCrashed;]true"
-                            # Report all of the test projects that crashed
-                            $crashedRuns = "$env:CRASHEDRUNS,$testProjectName".TrimStart(',')
-                            Write-Host "##vso[task.setvariable variable=CrashedRuns;]$crashedRuns"
-                            $crashed = $true
-                        }
-                        if ($innerXml -and ($innerXml.Contains('[ERROR]'))) {
-                            Write-Host "##vso[task.setvariable variable=StdOutFailure;]true"
-                            # Report all of the test projects that had stdout failures
-                            $stdOutFailureRuns = "$env:STDOUTFAILURERUNS,$testProjectName".TrimStart(',')
-                            Write-Host "##vso[task.setvariable variable=StdOutFailureRuns;]$stdOutFailureRuns"
-                            $crashed = $true
-                        }
-                    }
-                }
-                if ($reader.NodeType -eq [System.Xml.XmlNodeType]::EndElement -and $reader.Name -eq 'RunInfos') {
-                    $inRunInfos = $false
-                }
-            }
-        } finally {
-            $reader.Dispose()
-        }
-    } else {
-        Write-Host "WARNING: File not found: $testResultsFileName"
-    }
-    Write-Host "##vso[task.setvariable variable=TestResultsFileExists;]$testResultsFileExists"
-  displayName: 'Parse Test Results File'
-
-- pwsh: |
-    $testProjectName = "${{ parameters.testProjectName }}"
-    $testStdErrFileName = "$(Build.ArtifactStagingDirectory)/${{ parameters.testResultsArtifactName }}/${{ parameters.osName }}/${{ parameters.framework }}/${{ parameters.vsTestPlatform }}/$testProjectName/dotnet-test-error.log"
-    $testStdErrFileExists = Test-Path $testStdErrFileName
-    if ($testStdErrFileExists) {
-        $fileLength = (Get-Item $testStdErrFileName).Length
-        if ($fileLength -gt 0) {
-            $stream = [System.IO.StreamReader]::new($testStdErrFileName)
-            try {
-                while (-not $stream.EndOfStream) {
-                    $line = $stream.ReadLine()
-                    if ($line -match "Test Run Failed" -or $line -match "\[ERROR\]") {
-                        Write-Host "##vso[task.setvariable variable=StdErrFailure;]true"
-                        # Report all of the test projects that had stderr failures
-                        $stdErrFailureRuns = "$env:STDERRFAILURERUNS,$testProjectName".TrimStart(',')
-                        Write-Host "##vso[task.setvariable variable=StdErrFailureRuns;]$stdErrFailureRuns"
-                        break # No need to continue reading after detecting a failure
-                    }
-                }
-            } finally {
-                $stream.Dispose()
-            }
-        }
-    } else {
-        Write-Host "WARNING: File not found: $testStdErrFileName"
-    }
-  displayName: 'Parse StdErr File'
-
-- task: PublishTestResults@2
-  displayName: 'Publish Test Results ${{ parameters.testProjectName }},${{ parameters.framework }},${{ parameters.vsTestPlatform }}'
-  inputs:
-    testResultsFormat: ${{ parameters.testResultsFormat }}
-    testResultsFiles: '$(Build.ArtifactStagingDirectory)/${{ parameters.testResultsArtifactName }}/${{ parameters.osName }}/${{ parameters.framework }}/${{ parameters.vsTestPlatform }}/${{ parameters.testProjectName }}/${{ parameters.testResultsFileName }}'
-    testRunTitle: '${{ parameters.testProjectName }} - ${{ parameters.framework }} - ${{ parameters.vsTestPlatform }} - ${{ parameters.osName }} | $(TestResults)'
-  condition: and(succeeded(), eq(variables['TestResultsFileExists'], 'true'))
diff --git a/.build/azure-templates/run-tests-on-os.yml b/.build/azure-templates/run-tests-on-os.yml
index 735190d77..bb020904e 100644
--- a/.build/azure-templates/run-tests-on-os.yml
+++ b/.build/azure-templates/run-tests-on-os.yml
@@ -19,6 +19,15 @@
 # runs the tests for each project on a background job in parallel,
 # then uploads the results to Azure DevOps pipelines
 
+# Test results are parsed and published from within the "dotnet test" step rather than by one
+# PublishTestResults@2 task per project. The step emits the agent's own "results.publish" logging
+# command once per project, which is the same mechanism PublishTestResults@2 uses under the hood
+# (see Tasks/PublishTestResultsV2/publishtestresults.ts in microsoft/azure-pipelines-tasks and
+# src/Agent.Worker/TestResults/ResultsCommandExtension.cs in microsoft/azure-pipelines-agent).
+# Each project still gets its own test run with the same title and TRX attachment, but the 123
+# per-project parse/publish tasks (about 5 minutes per Windows job) are gone, and the uploads run
+# asynchronously while the remaining test projects are still executing.
+
 # NOTE: Depends on environment variables $(IsNightly), $(IsWeekly), and $(DisplayFullName)
 
 parameters:
@@ -34,6 +43,7 @@ parameters:
   maximumAllowedFailures: 0
   where: '' # A test filter expression, as defined by dotnet test
   dotNetSdkVersion: '' # The .NET SDK version to install
+  publishTestResultsInline: 'true' # Parse and publish each project's results as soon as its test run finishes, overlapping with the other projects. Set to 'false' to do it once after all projects have finished.
 
 steps:
 - checkout: none # self represents the repo where the initial Pipelines YAML file was found
@@ -173,6 +183,135 @@ steps:
     $isNightly = if ($env:ISNIGHTLY -eq 'true') { 'true' } else { 'false' }
     $isWeekly = if ($env:ISWEEKLY -eq 'true') { 'true' } else { 'false' }
     $displayFullName = if ($env:DISPLAYFULLNAME -eq 'false') { 'false' } else { 'true' }
+    $publishInline = '${{ parameters.publishTestResultsInline }}' -ne 'false'
+
+    # ---------------------------------------------------------------------------------------------
+    # Test result parsing and publishing
+    #
+    # Complete-TestProject parses one project's TestResults.trx and dotnet-test-error.log exactly as the
+    # previous per-project publish steps did, accumulates the same failure/crash information, and
+    # publishes the TRX as its own test run via the agent's "results.publish" logging command (the same
+    # command PublishTestResults@2 emits). The agent performs the upload asynchronously and waits for all
+    # of them at the end of this step. The variables the final "fail the job" step reads are set once,
+    # after every project has been handled.
+    # ---------------------------------------------------------------------------------------------
+    $script:processedTestProjects = [System.Collections.Generic.HashSet[string]]::new()
+    $script:publishedTestProjects = 0
+    $script:totalFailures = 0
+    $script:crashedRuns = [System.Collections.Generic.List[string]]::new()
+    $script:stdOutFailureRuns = [System.Collections.Generic.List[string]]::new()
+    $script:stdErrFailureRuns = [System.Collections.Generic.List[string]]::new()
+
+    # Escapes a logging command property value the same way azure-pipelines-task-lib does.
+    function ConvertTo-LoggingCommandValue([string]$value) {
+        return $value.Replace('%', '%AZP25').Replace("`r", '%0D').Replace("`n", '%0A').Replace(']', '%5D').Replace(';', '%3B')
+    }
+
+    function Complete-TestProject([string]$testName, [string]$testResultDirectory) {
+        if (!$script:processedTestProjects.Add($testName)) { return } # Already handled
+
+        $trxPath = Join-Path $testResultDirectory $testResultsFileName
+        if (!(Test-Path $trxPath)) {
+            Write-Host "WARNING: File not found: $trxPath (no test run will be published for $testName)"
+            return
+        }
+
+        # Parse the TRX: counters for the run title, and the RunInfos text for host crashes and [ERROR] output.
+        $failed = 0; $passed = 0; $ignored = 0
+        $countersFound = $false; $crashed = $false; $stdOutFailed = $false; $inRunInfos = $false
+        $reader = [System.Xml.XmlReader]::Create($trxPath)
+        try {
+            while ($reader.Read()) {
+                if ($reader.NodeType -eq [System.Xml.XmlNodeType]::Element) {
+                    if (!$countersFound -and $reader.Name -eq 'Counters') {
+                        $failed = [int]$reader.GetAttribute('failed')
+                        $passed = [int]$reader.GetAttribute('passed')
+                        $ignored = ([int]$reader.GetAttribute('total')) - ([int]$reader.GetAttribute('executed'))
+                        $countersFound = $true
+                    }
+                    if ($reader.Name -eq 'RunInfos') {
+                        $inRunInfos = $true
+                    }
+                    if ($inRunInfos -and $reader.Name -eq 'Text') {
+                        $innerXml = $reader.ReadInnerXml()
+                        if ($innerXml) {
+                            if (!$crashed -and ($innerXml.Contains('Test host process crashed') `
+                                -or $innerXml.Contains('Could not load file or assembly') `
+                                -or $innerXml.Contains("Could not find `'dotnet.exe`' host") `
+                                -or $innerXml.Contains('No test is available') `
+                                -or $innerXml.Contains('exited with error'))) {
+                                $crashed = $true
+                            }
+                            if (!$stdOutFailed -and $innerXml.Contains('[ERROR]')) {
+                                $stdOutFailed = $true
+                            }
+                        }
+                    }
+                }
+                if ($reader.NodeType -eq [System.Xml.XmlNodeType]::EndElement -and $reader.Name -eq 'RunInfos') {
+                    $inRunInfos = $false
+                }
+            }
+        } finally {
+            $reader.Dispose()
+        }
+
+        # Parse the captured stderr for failures that do not make it into the TRX.
+        $stdErrFailed = $false
+        $stdErrPath = Join-Path $testResultDirectory 'dotnet-test-error.log'
+        if (Test-Path $stdErrPath) {
+            if ((Get-Item $stdErrPath).Length -gt 0) {
+                $stream = [System.IO.StreamReader]::new($stdErrPath)
+                try {
+                    while (-not $stream.EndOfStream) {
+                        $line = $stream.ReadLine()
+                        if ($line -match "Test Run Failed" -or $line -match "\[ERROR\]") {
+                            $stdErrFailed = $true
+                            break
+                        }
+                    }
+                } finally {
+                    $stream.Dispose()
+                }
+            }
+        } else {
+            Write-Host "WARNING: File not found: $stdErrPath"
+        }
+
+        $script:totalFailures += $failed
+        if ($crashed) { $script:crashedRuns.Add($testName) }
+        if ($stdOutFailed) { $script:stdOutFailureRuns.Add($testName) }
+        if ($stdErrFailed) { $script:stdErrFailureRuns.Add($testName) }
+
+        $testResults = "Tests failed: $failed, passed: $passed, ignored: $ignored"
+        $flags = @()
+        if ($crashed) { $flags += 'HOST CRASHED' }
+        if ($stdOutFailed) { $flags += 'STDOUT [ERROR]' }
+        if ($stdErrFailed) { $flags += 'STDERR FAILURE' }
+        $flagText = if ($flags.Count -gt 0) { " [$($flags -join ', ')]" } else { '' }
+        Write-Host "$testName ($framework, $testPlatform, $testOSName): $testResults$flagText"
+
+        # Publish this project's TRX as its own test run. The title matches the one the
+        # PublishTestResults@2 tasks produced; platform/config additionally make runs filterable in the Tests tab.
+        $runTitle = "$testName - $framework - $testPlatform - $testOSName | $testResults"
+        $properties = "type=VSTest;mergeResults=false;publishRunAttachments=true;testRunSystem=VSTS - PTR" + `
+            ";platform=$(ConvertTo-LoggingCommandValue $testPlatform)" + `
+            ";config=$(ConvertTo-LoggingCommandValue $framework)" + `
+            ";runTitle=$(ConvertTo-LoggingCommandValue $runTitle)" + `
+            ";resultFiles=$(ConvertTo-LoggingCommandValue $trxPath)"
+        Write-Host "##vso[results.publish $properties]"
+        $script:publishedTestProjects++
+    }
+
+    # Handles every background test job that has finished since the last call.
+    function Complete-FinishedTestJobs() {
+        if (!$publishInline) { return }
+        foreach ($job in @(Get-Job | Where-Object { $_.State -in @('Completed', 'Failed', 'Stopped') })) {
+            $jobTestName = ($job.Name -split ',')[0]
+            if ($script:processedTestProjects.Contains($jobTestName)) { continue }
+            Complete-TestProject -TestName $jobTestName -TestResultDirectory "$testResultsArtifactDirectory/$testOSName/$framework/$testPlatform/$jobTestName"
+        }
+    }
 
     function IsSupportedFramework([string]$framework) {
         if ($IsWindows -eq $null) {
@@ -200,6 +339,7 @@ steps:
                     Write-Host "  Running tests in parallel on $($running.Count) projects." -ForegroundColor Cyan
                     Write-Host "  Next in queue is $testName on $framework. This will take a bit, please wait..." -ForegroundColor Cyan
                     $running | Wait-Job -Any | Out-Null
+                    Complete-FinishedTestJobs
                 }
             }
 
@@ -235,6 +375,9 @@ steps:
             Write-Host $testExpression -ForegroundColor Magenta
             if ($maximumParalellJobs -le 1) {
                 Invoke-Expression $testExpression # For running in the foreground
+                if ($publishInline) {
+                    Complete-TestProject -TestName $testName -TestResultDirectory $testResultDirectory
+                }
             } else {
 
                 $testExpression += " > ""$testResultDirectory/dotnet-test.log"" 2> ""$testResultDirectory/dotnet-test-error.log"""
@@ -268,10 +411,41 @@ steps:
                     Write-Host "$number. $jobName"
                 }
                 $running | Wait-Job -Any
+                Complete-FinishedTestJobs
             }
         } until ($running.Count -eq 0)
     }
 
+    Write-Host "##[section]Parsing and publishing test results"
+    $stopwatch = [System.Diagnostics.Stopwatch]::StartNew()
+
+    # Handle everything not yet processed: every project when inline publishing is off,
+    # otherwise only stragglers (for example a project whose job ended in a state we did not observe).
+    $resultsRoot = "$testResultsArtifactDirectory/$testOSName/$framework/$testPlatform"
+    if (Test-Path $resultsRoot) {
+        foreach ($resultDirectory in @(Get-ChildItem -Path $resultsRoot -Directory | Sort-Object -Property Name)) {
+            Complete-TestProject -TestName $resultDirectory.Name -TestResultDirectory $resultDirectory.FullName
+        }
+    } else {
+        Write-Host "WARNING: Test results directory not found: $resultsRoot"
+    }
+
+    $stopwatch.Stop()
+    Write-Host "Parsed $($script:processedTestProjects.Count) test result directories and queued $($script:publishedTestProjects) test runs for upload in $($stopwatch.Elapsed.TotalSeconds.ToString('0.0')) seconds. The agent finishes the uploads before this step completes."
+
+    # These variables drive the final step of the job, which fails the job and lists the offending projects.
+    $hostCrashed = if ($script:crashedRuns.Count -gt 0) { 'true' } else { 'false' }
+    $stdOutFailure = if ($script:stdOutFailureRuns.Count -gt 0) { 'true' } else { 'false' }
+    $stdErrFailure = if ($script:stdErrFailureRuns.Count -gt 0) { 'true' } else { 'false' }
+    Write-Host "##vso[task.setvariable variable=TotalFailures;]$($script:totalFailures)"
+    Write-Host "##vso[task.setvariable variable=HostCrashed;]$hostCrashed"
+    Write-Host "##vso[task.setvariable variable=CrashedRuns;]$($script:crashedRuns -join ',')"
+    Write-Host "##vso[task.setvariable variable=StdOutFailure;]$stdOutFailure"
+    Write-Host "##vso[task.setvariable variable=StdOutFailureRuns;]$($script:stdOutFailureRuns -join ',')"
+    Write-Host "##vso[task.setvariable variable=StdErrFailure;]$stdErrFailure"
+    Write-Host "##vso[task.setvariable variable=StdErrFailureRuns;]$($script:stdErrFailureRuns -join ',')"
+    Write-Host "Total failures: $($script:totalFailures); crashed: $hostCrashed; stdout failures: $stdOutFailure; stderr failures: $stdErrFailure"
+
     $global:LASTEXITCODE = 0 # Force the script to continue on error
   displayName: 'dotnet test ${{ parameters.framework }},${{ parameters.vsTestPlatform }}'
   ignoreLASTEXITCODE: true
@@ -285,19 +459,6 @@ steps:
     ArtifactName: '${{ parameters.testResultsArtifactName }}_${{ parameters.osName }}_${{ parameters.framework }}_${{ parameters.vsTestPlatform }}__JobID_$(System.JobId)'
   condition: succeededOrFailed()
 
-# Due to the fact that it is not possible to loop a task and
-# it would be a ton of work to make a replacement for the
-# Publish Test Results task or the (deprecated) TfsPublisher
-# our only other option is to make a task for every supported
-# platform and project and update it whenever a new platform
-# is targeted or test project is created in Lucene.Net.
-
-- template: 'publish-test-results-for-test-projects.yml'
-  parameters:
-    osName: '${{ parameters.osName }}'
-    framework: '${{ parameters.framework }}'
-    vsTestPlatform: '${{ parameters.vsTestPlatform }}'
-
 - pwsh: |
     $failed = $false
     if ($env:HOSTCRASHED -eq 'true') {