azure-pipelines.yml

# Starter pipeline
# Start with a minimal pipeline that you can customize to build and deploy your code.
# Add steps that build, run tests, deploy, and more:
# https://aka.ms/yaml

name: 'vNext$(rev:.r)' # Format for build number (will be overridden)

#trigger:
#- master

# DevOps Setup: Define the following pipeline level variables in Azure DevOps build pipeline
#
# ArtifactFeedID: (Optional - set to your Azure DevOps Artifact (NuGet) feed. If not provided, publish job will be skipped.)
# BuildConfiguration: 'Release' (Optional - the solution build configuration to run.)
# BuildPlatform: 'Any CPU' (Optional - the build platform to use when compiling assemblies.)
# RunTests: 'true' (Optional - set to 'false' to disable test jobs - useful for debugging. If not provided, tests will be run.)
# RunX86Tests: 'false' (Optional - set to 'true' to enable x86 tests)
#
# PackageVersion: '' (Optional. Will be generated from nbgv if not provided. The version of the NuGet package.)
# AssemblyVersion: '' (Optional. Will be generated from nbgv if not provided. The assembly version (affects binary compatibility). This should always be the same as the previous version unless a binary breaking change happens (i.e. porting a new version).)
# FileVersion: '' (Optional. Will be generated from nbgv if not provided. The version that is visible on the assembly file.)
# InformationalVersion: '' (Optional. Will be generated from nbgv if not provided. If provided, the git commit hash will be appended to the end of the value.)

variables:
- name: TestTargetFrameworks
  value: 'net9.0;net8.0;net6.0;net48;net472;net471;net47'
- name: DotNetSDKVersion
  value: '9.0.100'
- name: BinaryArtifactName
  value: 'testbinaries'
- name: NuGetArtifactName
  value: 'nuget'
- name: TestResultsArtifactName
  value: 'testresults'
- name: VersionArtifactName
  value: 'version'
- name: BuildNumberFileName
  value: 'buildNumber.txt'
- name: PackageVersionFileName
  value: 'packageVersion.txt'
- name: FileVersionFileName
  value: 'fileVersion.txt'

stages:
- stage: Build_Stage
  displayName: 'Build Stage:'
  jobs:

  - job: Build
    pool:
      vmImage: 'windows-2019'

    steps:
    # Nerdbank.GitVersioning requires a deep clone. See: https://github.com/dotnet/Nerdbank.GitVersioning/blob/main/doc/cloudbuild.md#azure-pipelines
    - checkout: self
      fetchDepth: 0

    #- template: '.build/azure-templates/show-all-files.yml' # for debugging
    #- pwsh: C:;cd $env:ANDROID_HOME;dir -r  | Where-Object {$_.PsIsContainer -eq $false} | % { $_.FullName }

    - pwsh: |
        $configuration = if ($env:BUILDCONFIGURATION) { $env:BUILDCONFIGURATION } else { "Release" }
        Write-Host "##vso[task.setvariable variable=BuildConfiguration;]$configuration"
        $platform = if ($env:BUILDPLATFORM) { $env:BUILDPLATFORM } else { "Any CPU" }
        Write-Host "##vso[task.setvariable variable=BuildPlatform;]$platform"
        $informationalVersion = if ($env:INFORMATIONALVERSION) { $env:INFORMATIONALVERSION } else { '' }
        Write-Host "##vso[task.setvariable variable=InformationalVersion;]$informationalVersion"
        $fileVersion = if ($env:FILEVERSION) { $env:FILEVERSION } else { '' }
        Write-Host "##vso[task.setvariable variable=FileVersion;]$fileVersion"
        $assemblyVersion = if ($env:ASSEMBLYVERSION) { $env:ASSEMBLYVERSION } else { '' }
        Write-Host "##vso[task.setvariable variable=AssemblyVersion;]$assemblyVersion"
        $packageVersion = if ($env:PACKAGEVERSION) { $env:PACKAGEVERSION } else { '' }
        Write-Host "##vso[task.setvariable variable=PackageVersion;]$packageVersion"
      displayName: 'Setup Default Variable Values'

    - template: '.build/azure-templates/install-dotnet-sdk.yml'
      parameters:
        sdkVersion: '$(DotNetSDKVersion)'
    
    - template: '.build/azure-templates/gitversioning-increment-and-persist-versions.yml'
      parameters:
        informationalVersion: '$(InformationalVersion)' # Input passed in from pipeline
        fileVersion: '$(FileVersion)' # Input passed in from pipeline
        assemblyVersion: '$(AssemblyVersion)' # Input passed in from pipeline
        packageVersion: '$(PackageVersion)' # Input passed in from pipeline
        versionArtifactName: '$(VersionArtifactName)'
        packageVersionFileName: '$(PackageVersionFileName)'
        fileVersionFileName: '$(FileVersionFileName)'
        buildNumberFileName: '$(BuildNumberFileName)'

    - template: '.build/azure-templates/build-pack-and-publish-libraries.yml'
      parameters:
        artifactFeedID: '$(ArtifactFeedID)'
        testTargetFrameworks: '$(TestTargetFrameworks)'
        informationalVersion: '$(CI_InformationalVersion)' # Output from gitversioning-increment-and-persist-versions.yml
        fileVersion: '$(CI_FileVersion)' # Output from gitversioning-increment-and-persist-versions.yml
        assemblyVersion: '$(CI_AssemblyVersion)' # Output from gitversioning-increment-and-persist-versions.yml
        packageVersion: '$(CI_PackageVersion)' # Output from gitversioning-increment-and-persist-versions.yml
        buildConfiguration: '$(BuildConfiguration)'
        buildPlatform: '$(BuildPlatform)'
        nugetArtifactName: '$(NuGetArtifactName)'
        binaryArtifactName: '$(BinaryArtifactName)'

    - task: PublishPipelineArtifact@1
      displayName: 'Publish Artifact: $(BinaryArtifactName)'
      inputs:
        targetPath: '$(Build.ArtifactStagingDirectory)/$(BinaryArtifactName)'
        artifact: '$(BinaryArtifactName)'
        publishLocation: 'pipeline'
      condition: succeededOrFailed()

- stage: Test_Stage
  displayName: 'Test Stage:'
  jobs:

  - job: Test_net48_x64
    condition: and(succeeded(), ne(variables['RunTests'], 'false'))
    displayName: 'Test net48,x64 on Windows'
    pool:
      vmImage: 'windows-latest'
    steps:
    - template: '.build/azure-templates/run-tests-on-os.yml'
      parameters:
        osName: 'Windows'
        testTargetFramework: 'net48'
        vsTestPlatform: 'x64'
        testResultsArtifactName: '$(TestResultsArtifactName)'
        maximumAllowedFailures: 0 # Maximum allowed failures for a successful build
        dotNetSdkVersion: '$(DotNetSDKVersion)'

  - job: Test_net48_x86 # Only run if explicitly enabled with RunX86Tests
    condition: and(succeeded(), ne(variables['RunTests'], 'false'), eq(variables['RunX86Tests'], 'true'))
    displayName: 'Test net48,x86 on Windows'
    pool:
      vmImage: 'windows-latest'
    steps:
    - template: '.build/azure-templates/run-tests-on-os.yml'
      parameters:
        osName: 'Windows'
        testTargetFramework: 'net48'
        vsTestPlatform: 'x86'
        testResultsArtifactName: '$(TestResultsArtifactName)'
        maximumAllowedFailures: 0 # Maximum allowed failures for a successful build
        dotNetSdkVersion: '$(DotNetSDKVersion)'

  - job: Test_net472_x64
    condition: and(succeeded(), ne(variables['RunTests'], 'false'))
    displayName: 'Test net472,x64 on Windows'
    pool:
      vmImage: 'windows-latest'
    steps:
    - template: '.build/azure-templates/run-tests-on-os.yml'
      parameters:
        osName: 'Windows'
        testTargetFramework: 'net472'
        vsTestPlatform: 'x64'
        testResultsArtifactName: '$(TestResultsArtifactName)'
        maximumAllowedFailures: 0 # Maximum allowed failures for a successful build
        dotNetSdkVersion: '$(DotNetSDKVersion)'

  - job: Test_net472_x86 # Only run if explicitly enabled with RunX86Tests
    condition: and(succeeded(), ne(variables['RunTests'], 'false'), eq(variables['RunX86Tests'], 'true'))
    displayName: 'Test net472,x86 on Windows'
    pool:
      vmImage: 'windows-latest'
    steps:
    - template: '.build/azure-templates/run-tests-on-os.yml'
      parameters:
        osName: 'Windows'
        testTargetFramework: 'net472'
        vsTestPlatform: 'x86'
        testResultsArtifactName: '$(TestResultsArtifactName)'
        maximumAllowedFailures: 0 # Maximum allowed failures for a successful build
        dotNetSdkVersion: '$(DotNetSDKVersion)'

  - job: Test_net471_x64
    condition: and(succeeded(), ne(variables['RunTests'], 'false'))
    displayName: 'Test net471,x64 on Windows'
    pool:
      vmImage: 'windows-latest'
    steps:
    - template: '.build/azure-templates/run-tests-on-os.yml'
      parameters:
        osName: 'Windows'
        testTargetFramework: 'net471'
        vsTestPlatform: 'x64'
        testResultsArtifactName: '$(TestResultsArtifactName)'
        maximumAllowedFailures: 0 # Maximum allowed failures for a successful build
        dotNetSdkVersion: '$(DotNetSDKVersion)'

  - job: Test_net471_x86 # Only run if explicitly enabled with RunX86Tests
    condition: and(succeeded(), ne(variables['RunTests'], 'false'), eq(variables['RunX86Tests'], 'true'))
    displayName: 'Test net471,x86 on Windows'
    pool:
      vmImage: 'windows-latest'
    steps:
    - template: '.build/azure-templates/run-tests-on-os.yml'
      parameters:
        osName: 'Windows'
        testTargetFramework: 'net471'
        vsTestPlatform: 'x86'
        testResultsArtifactName: '$(TestResultsArtifactName)'
        maximumAllowedFailures: 0 # Maximum allowed failures for a successful build
        dotNetSdkVersion: '$(DotNetSDKVersion)'

  - job: Test_net47_x64
    condition: and(succeeded(), ne(variables['RunTests'], 'false'))
    displayName: 'Test net47,x64 on Windows'
    pool:
      vmImage: 'windows-latest'
    steps:
    - template: '.build/azure-templates/run-tests-on-os.yml'
      parameters:
        osName: 'Windows'
        testTargetFramework: 'net47'
        vsTestPlatform: 'x64'
        testResultsArtifactName: '$(TestResultsArtifactName)'
        maximumAllowedFailures: 0 # Maximum allowed failures for a successful build
        dotNetSdkVersion: '$(DotNetSDKVersion)'

  - job: Test_net47_x86 # Only run if explicitly enabled with RunX86Tests
    condition: and(succeeded(), ne(variables['RunTests'], 'false'), eq(variables['RunX86Tests'], 'true'))
    displayName: 'Test net47,x86 on Windows'
    pool:
      vmImage: 'windows-latest'
    steps:
    - template: '.build/azure-templates/run-tests-on-os.yml'
      parameters:
        osName: 'Windows'
        testTargetFramework: 'net47'
        vsTestPlatform: 'x86'
        testResultsArtifactName: '$(TestResultsArtifactName)'
        maximumAllowedFailures: 0 # Maximum allowed failures for a successful build
        dotNetSdkVersion: '$(DotNetSDKVersion)'

  - job: Test_net9_0_x64
    condition: and(succeeded(), ne(variables['RunTests'], 'false'))
    strategy:
      matrix:
        Windows:
          osName: 'Windows'
          imageName: 'windows-latest'
          maximumAllowedFailures: 0 # Maximum allowed failures for a successful build
        Linux:
          osName: 'Linux'
          imageName: 'ubuntu-latest'
          maximumAllowedFailures: 0 # Maximum allowed failures for a successful build
        macOS:
          osName: 'macOS'
          imageName: 'macOS-latest'
          maximumAllowedFailures: 0 # Maximum allowed failures for a successful build
    displayName: 'Test net9.0,x64 on'
    pool:
      vmImage: $(imageName)
    steps:
    - template: '.build/azure-templates/run-tests-on-os.yml'
      parameters:
        osName: $(osName)
        testTargetFramework: 'net9.0'
        vsTestPlatform: 'x64'
        testResultsArtifactName: '$(TestResultsArtifactName)'
        maximumAllowedFailures: $(maximumAllowedFailures)
        dotNetSdkVersion: '$(DotNetSDKVersion)'

  - job: Test_net9_0_x86 # Only run if explicitly enabled with RunX86Tests
    condition: and(succeeded(), ne(variables['RunTests'], 'false'), eq(variables['RunX86Tests'], 'true'))
    strategy:
      matrix:
        Windows:
          osName: 'Windows'
          imageName: 'windows-latest'
          maximumAllowedFailures: 0 # Maximum allowed failures for a successful build
    displayName: 'Test net9.0,x86 on'
    pool:
      vmImage: $(imageName)
    steps:
    - template: '.build/azure-templates/run-tests-on-os.yml'
      parameters:
        osName: $(osName)
        testTargetFramework: 'net9.0'
        vsTestPlatform: 'x86'
        testResultsArtifactName: '$(TestResultsArtifactName)'
        maximumAllowedFailures: $(maximumAllowedFailures)
        dotNetSdkVersion: '$(DotNetSDKVersion)'

  - job: Test_net8_0_x64
    condition: and(succeeded(), ne(variables['RunTests'], 'false'))
    strategy:
      matrix:
        Windows:
          osName: 'Windows'
          imageName: 'windows-latest'
          maximumAllowedFailures: 0 # Maximum allowed failures for a successful build
        Linux:
          osName: 'Linux'
          imageName: 'ubuntu-latest'
          maximumAllowedFailures: 0 # Maximum allowed failures for a successful build
        macOS:
          osName: 'macOS'
          imageName: 'macOS-latest'
          maximumAllowedFailures: 0 # Maximum allowed failures for a successful build
    displayName: 'Test net8.0,x64 on'
    pool:
      vmImage: $(imageName)
    steps:
    - template: '.build/azure-templates/run-tests-on-os.yml'
      parameters:
        osName: $(osName)
        testTargetFramework: 'net8.0'
        vsTestPlatform: 'x64'
        testResultsArtifactName: '$(TestResultsArtifactName)'
        maximumAllowedFailures: $(maximumAllowedFailures)
        dotNetSdkVersion: '$(DotNetSDKVersion)'

  - job: Test_net8_0_x86 # Only run if explicitly enabled with RunX86Tests
    condition: and(succeeded(), ne(variables['RunTests'], 'false'), eq(variables['RunX86Tests'], 'true'))
    strategy:
      matrix:
        Windows:
          osName: 'Windows'
          imageName: 'windows-latest'
          maximumAllowedFailures: 0 # Maximum allowed failures for a successful build
    displayName: 'Test net8.0,x86 on'
    pool:
      vmImage: $(imageName)
    steps:
    - template: '.build/azure-templates/run-tests-on-os.yml'
      parameters:
        osName: $(osName)
        testTargetFramework: 'net8.0'
        vsTestPlatform: 'x86'
        testResultsArtifactName: '$(TestResultsArtifactName)'
        maximumAllowedFailures: $(maximumAllowedFailures)
        dotNetSdkVersion: '$(DotNetSDKVersion)'

  - job: Test_net6_0_x64
    condition: and(succeeded(), ne(variables['RunTests'], 'false'))
    strategy:
      matrix:
        Windows:
          osName: 'Windows'
          imageName: 'windows-latest'
          maximumAllowedFailures: 0 # Maximum allowed failures for a successful build
        Linux:
          osName: 'Linux'
          imageName: 'ubuntu-latest'
          maximumAllowedFailures: 0 # Maximum allowed failures for a successful build
        macOS:
          osName: 'macOS'
          imageName: 'macOS-latest'
          maximumAllowedFailures: 0 # Maximum allowed failures for a successful build
    displayName: 'Test net6.0,x64 on'
    pool:
      vmImage: $(imageName)
    steps:
    - template: '.build/azure-templates/run-tests-on-os.yml'
      parameters:
        osName: $(osName)
        testTargetFramework: 'net6.0'
        vsTestPlatform: 'x64'
        testResultsArtifactName: '$(TestResultsArtifactName)'
        maximumAllowedFailures: $(maximumAllowedFailures)
        dotNetSdkVersion: '$(DotNetSDKVersion)'

  - job: Test_net6_0_x86 # Only run if explicitly enabled with RunX86Tests
    condition: and(succeeded(), ne(variables['RunTests'], 'false'), eq(variables['RunX86Tests'], 'true'))
    strategy:
      matrix:
        Windows:
          osName: 'Windows'
          imageName: 'windows-latest'
          maximumAllowedFailures: 0 # Maximum allowed failures for a successful build
    displayName: 'Test net6.0,x86 on'
    pool:
      vmImage: $(imageName)
    steps:
    - template: '.build/azure-templates/run-tests-on-os.yml'
      parameters:
        osName: $(osName)
        testTargetFramework: 'net6.0'
        vsTestPlatform: 'x86'
        testResultsArtifactName: '$(TestResultsArtifactName)'
        maximumAllowedFailures: $(maximumAllowedFailures)
        dotNetSdkVersion: '$(DotNetSDKVersion)'


- stage: Publish_Stage
  displayName: 'Publish Stage:'
  jobs:
  - job: Publish
    condition: and(succeeded(), ne(variables['ArtifactFeedID'], ''))
    pool:
      vmImage: 'windows-latest'

    steps:
    - template: '.build/azure-templates/show-all-environment-variables.yml'

    - task: DownloadBuildArtifacts@0
      displayName: 'Download Build Artifacts: $(VersionArtifactName)'
      inputs:
        artifactName: '$(VersionArtifactName)'
        downloadPath: '$(Build.ArtifactStagingDirectory)'

      # NOTE: We are setting Build.BuildNumber here to the NuGet package version to work around the limitation that
      # the version cannot be passed to the Index Sources & Publish Symbols task.
    - pwsh: |
        $version = Get-Content '$(Build.ArtifactStagingDirectory)/$(VersionArtifactName)/$(PackageVersionFileName)' -Raw
        Write-Host "##vso[task.setvariable variable=PackageVersion;]$version"
        Write-Host "##vso[build.updatebuildnumber]$version"
      displayName: 'Read PackageVersion from File to Build.BuildNumber'

    - template: '.build/azure-templates/show-all-environment-variables.yml'

    - template: '.build/azure-templates/publish-nuget-packages.yml'
      parameters:
        artifactFeedID: '$(ArtifactFeedID)'
        nugetArtifactName: '$(NuGetArtifactName)'