runtime.yml

# Setting batch to true, triggers one build at a time.
# if there is a push while a build in progress, it will wait,
# until the running build finishes, and produce a build with all the changes
# that happened during the last build.
trigger:
  batch: true
  branches:
    include:
    - master
    - dev/infrastructure
    - release/*.*
  paths:
    include:
    - '*'
    - docs/manpages/*
    exclude:
    - eng/Version.Details.xml
    - .github/*
    - docs/*
    - CODE-OF-CONDUCT.md
    - CONTRIBUTING.md
    - LICENSE.TXT
    - PATENTS.TXT
    - README.md
    - SECURITY.md
    - THIRD-PARTY-NOTICES.TXT

pr:
  branches:
    include:
    - master
    - dev/infrastructure
    - release/*.*
  paths:
    include:
    - '*'
    - docs/manpages/*
    exclude:
    - eng/Version.Details.xml
    - .github/*
    - docs/*
    - CODE-OF-CONDUCT.md
    - CONTRIBUTING.md
    - LICENSE.TXT
    - PATENTS.TXT
    - README.md
    - SECURITY.md
    - THIRD-PARTY-NOTICES.TXT

variables:
  - template: /eng/pipelines/common/variables.yml

jobs:
#
# Checkout repository
#
- template: /eng/pipelines/common/checkout-job.yml
  parameters:
    paths:
    - subset: coreclr
      include:
      - src/libraries/System.Private.CoreLib/*
      - src/libraries/Native/Unix/System.Globalization.Native/*
      - src/libraries/Native/Unix/Common/*
      exclude:
      - eng/Version.Details.xml
      - '*.md'
      - LICENSE.TXT
      - PATENTS.TXT
      - THIRD-PARTY-NOTICES.TXT
      - docs/*
      - src/installer/*
      - src/mono/*
      - src/libraries/*
      - eng/pipelines/installer/*
      - eng/pipelines/mono/*
      - eng/pipelines/libraries/*
    - subset: mono
      include:
      - src/libraries/System.Private.CoreLib/*
      - src/libraries/Native/Unix/System.Globalization.Native/*
      - src/libraries/Native/Unix/Common/*
      exclude:
      - eng/Version.Details.xml
      - '*.md'
      - LICENSE.TXT
      - PATENTS.TXT
      - THIRD-PARTY-NOTICES.TXT
      - docs/*
      - src/installer/*
      - src/coreclr/*
      - src/libraries/*
      - eng/pipelines/installer/*
      - eng/pipelines/coreclr/*
      - eng/pipelines/libraries/*
    - subset: libraries
      exclude:
      - eng/Version.Details.xml
      - '*.md'
      - LICENSE.TXT
      - PATENTS.TXT
      - THIRD-PARTY-NOTICES.TXT
      - docs/*
      - src/installer/*
      - src/mono/*
      - src/coreclr/*
      - eng/pipelines/coreclr/*
      - eng/pipelines/mono/*
      - eng/pipelines/installer/*
    - subset: runtimetests
      include:
      - src/tests/*
      - src/coreclr/tests/*
      - src/coreclr/build-test.cmd
      - src/coreclr/build-test.sh
    - subset: installer
      include:
      - docs/manpages/*
      exclude:
      - eng/Version.Details.xml
      - '*.md'
      - LICENSE.TXT
      - PATENTS.TXT
      - THIRD-PARTY-NOTICES.TXT
      - docs/*
      - src/coreclr/*
      - src/mono/*
      - src/libraries/*
      - eng/pipelines/coreclr/*
      - eng/pipelines/mono/*
      - eng/pipelines/libraries/*

#
# Build CoreCLR checked
# Only when CoreCLR is changed
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/coreclr/templates/build-job.yml
    buildConfig: checked
    platforms:
    - Linux_x64
    - Linux_arm
    - Linux_arm64
    - Linux_musl_arm64
    - Linux_musl_x64
    - Windows_NT_x86
    - Windows_NT_x64
    - Windows_NT_arm
    - Windows_NT_arm64
    jobParameters:
      testGroup: innerloop
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_coreclr.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(variables['isFullMatrix'], true))

#
# Build CoreCLR checked using GCC toolchain
# Only when CoreCLR is changed
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/coreclr/templates/build-job.yml
    buildConfig: checked
    platforms:
    - Linux_x64
    jobParameters:
      testGroup: innerloop
      compilerName: gcc
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_coreclr.containsChange'], true),
          eq(variables['isFullMatrix'], true))

#
# Build CoreCLR OSX_x64 checked
# Only when CoreCLR or Libraries is changed
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/coreclr/templates/build-job.yml
    buildConfig: checked
    platforms:
    - OSX_x64
    jobParameters:
      testGroup: innerloop
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_coreclr.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(variables['isFullMatrix'], true))

#
# Build CoreCLR release
# Always as they are needed by Installer and we always build and test the Installer.
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/coreclr/templates/build-job.yml
    buildConfig: release
    platforms:
    - OSX_x64
    - Linux_x64
    - Linux_arm
    - Linux_arm64
    - Linux_musl_x64
    - Linux_musl_arm64
    - Windows_NT_x64
    - Windows_NT_x86
    - Windows_NT_arm
    - Windows_NT_arm64
    - FreeBSD_x64
    jobParameters:
      testGroup: innerloop

#
# Build CoreCLR Formatting Job
# Only when CoreCLR is changed, and only in the 'master' branch (no release branches;
# both CI and PR builds).
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/coreclr/templates/format-job.yml
    platforms:
    - Linux_x64
    # Isssue: https://github.com/dotnet/runtime/issues/40034
    #- Windows_NT_x64
    jobParameters:
      condition: >-
        and(
          or(
            eq(variables['Build.SourceBranchName'], 'master'),
            eq(variables['System.PullRequest.TargetBranch'], 'master')),
          or(
            eq(dependencies.checkout.outputs['SetPathVars_coreclr.containsChange'], true),
            eq(variables['isFullMatrix'], true)))

# Build and test clr tools
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/coreclr/templates/build-job.yml
    buildConfig: checked
    platforms:
    - Linux_x64
    jobParameters:
      testGroup: clrTools
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_coreclr.containsChange'], true),
          eq(variables['isFullMatrix'], true))

# Build the whole product using Mono runtime
# Only when libraries, mono or installer are changed
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/common/global-build-job.yml
    buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
    runtimeFlavor: mono
    platforms:
    - Android_x86
    - Android_arm64
    - tvOS_x64
    - iOS_arm64
    - iOS_x86
    - Linux_arm
    jobParameters:
      testGroup: innerloop
      nameSuffix: AllSubsets_Mono
      buildArgs: -s mono+libs+installer -c $(_BuildConfig)
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_installer.containsChange'], true),
          eq(variables['isFullMatrix'], true))

- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/common/global-build-job.yml
    buildConfig: Release
    runtimeFlavor: mono
    platforms:
    - Android_x64
    - Android_arm
    - tvOS_arm64
    - iOS_arm
    - iOS_x64
    - Linux_musl_x64
    jobParameters:
      testGroup: innerloop
      nameSuffix: AllSubsets_Mono
      buildArgs: -s mono+libs+installer -c $(_BuildConfig)
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_installer.containsChange'], true),
          eq(variables['isFullMatrix'], true))

#
# Build the whole product using Mono and run tests
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/common/global-build-job.yml
    helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
    buildConfig: Release
    runtimeFlavor: mono
    platforms:
    - Browser_wasm
    variables:
      # map dependencies variables to local variables
      - name: librariesContainsChange
        value: $[ dependencies.checkout.outputs['SetPathVars_libraries.containsChange'] ]
      - name: monoContainsChange
        value: $[ dependencies.checkout.outputs['SetPathVars_mono.containsChange'] ]
    jobParameters:
      testGroup: innerloop
      nameSuffix: AllSubsets_Mono
      buildArgs: -s mono+libs+installer+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true
      timeoutInMinutes: 120
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_installer.containsChange'], true),
          eq(variables['isFullMatrix'], true))
      # extra steps, run tests
      extraStepsTemplate: /eng/pipelines/libraries/helix.yml
      extraStepsParameters:
        creator: dotnet-bot
        testRunNamePrefixSuffix: Mono_$(_BuildConfig)
        condition: >-
          or(
          eq(variables['librariesContainsChange'], true),
          eq(variables['monoContainsChange'], true),
          eq(variables['isFullMatrix'], true))

#
# Build Mono and Installer on LLVMJIT mode
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/common/global-build-job.yml
    buildConfig: Release
    runtimeFlavor: mono
    platforms:
    - OSX_x64
    jobParameters:
      testGroup: innerloop
      nameSuffix: AllSubsets_Mono_LLVMJIT
      buildArgs: -s mono+libs+installer -c $(_BuildConfig)
                 /p:MonoEnableLLVM=true /p:MonoBundleLLVMOptimizer=false
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_installer.containsChange'], true),
          eq(variables['isFullMatrix'], true))

- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/common/global-build-job.yml
    buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
    runtimeFlavor: mono
    platforms:
    - Linux_x64
    - Linux_arm64
    jobParameters:
      testGroup: innerloop
      nameSuffix: AllSubsets_Mono_LLVMJIT
      buildArgs: -s mono+libs+installer -c $(_BuildConfig)
                 /p:MonoEnableLLVM=true /p:MonoBundleLLVMOptimizer=false
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_installer.containsChange'], true),
          eq(variables['isFullMatrix'], true))

#
# Build Mono and Installer on LLVMAOT mode
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/common/global-build-job.yml
    buildConfig: Release
    runtimeFlavor: mono
    platforms:
    - Linux_x64
    - Linux_arm64
    jobParameters:
      testGroup: innerloop
      nameSuffix: AllSubsets_Mono_LLVMAOT
      buildArgs: -s mono+libs+installer -c $(_BuildConfig)
                 /p:MonoEnableLLVM=true /p:MonoBundleLLVMOptimizer=true
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_installer.containsChange'], true),
          eq(variables['isFullMatrix'], true))

- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/common/global-build-job.yml
    buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
    runtimeFlavor: mono
    platforms:
    - OSX_x64
    jobParameters:
      testGroup: innerloop
      nameSuffix: AllSubsets_Mono_LLVMAOT
      buildArgs: -s mono+libs+installer -c $(_BuildConfig)
                 /p:MonoEnableLLVM=true /p:MonoBundleLLVMOptimizer=true
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_installer.containsChange'], true),
          eq(variables['isFullMatrix'], true))

#
# Build Mono debug
# Only when libraries or mono changed
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/mono/templates/build-job.yml
    runtimeFlavor: mono
    buildConfig: debug
    platforms:
    - OSX_x64
    - Linux_x64
    - Linux_arm64
    # - Linux_musl_arm64
    - Windows_NT_x64
    # - Windows_NT_x86
    # - Windows_NT_arm
    # - Windows_NT_arm64
    jobParameters:
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_mono.containsChange'], true),
          eq(variables['isFullMatrix'], true))

#
# Build Mono release
# Only when libraries or mono changed
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/mono/templates/build-job.yml
    runtimeFlavor: mono
    buildConfig: release
    platforms:
    - Linux_x64
    # - Linux_musl_arm64
    - Windows_NT_x64
    # - Windows_NT_x86
    # - Windows_NT_arm
    # - Windows_NT_arm64
    jobParameters:
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_mono.containsChange'], true),
          eq(variables['isFullMatrix'], true))

#
# Build Mono release
# Only when libraries, mono, or the runtime tests changed
# Currently only these architectures are needed for the runtime tests.
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/mono/templates/build-job.yml
    runtimeFlavor: mono
    buildConfig: release
    platforms:
    - OSX_x64
    - Linux_arm64
    jobParameters:
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_mono.containsChange'], true),
          eq(variables['isFullMatrix'], true))

#
# Build Mono release with LLVM AOT
# Only when mono, or the runtime tests changed
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/mono/templates/build-job.yml
    runtimeFlavor: mono
    buildConfig: release
    platforms:
    - Linux_x64
    jobParameters:
      runtimeVariant: llvmaot
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_mono.containsChange'], true),
          eq(variables['isFullMatrix'], true))

#
# Build libraries using live CoreLib
# These set of libraries are built always no matter what changed
# The reason for that is because Corelib and Installer needs it and
# These are part of the test matrix for Libraries changes.
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/libraries/build-job.yml
    buildConfig: Release
    platforms:
    - Linux_arm
    - Linux_musl_arm64
    - Windows_NT_arm
    - Windows_NT_arm64
    - Windows_NT_x86
    jobParameters:
      liveRuntimeBuildConfig: release

- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/libraries/build-job.yml
    buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
    platforms:
    - Linux_arm64
    - Linux_musl_x64
    - Linux_x64
    - OSX_x64
    - Windows_NT_x64
    - FreeBSD_x64
    jobParameters:
      testScope: innerloop
      testBuildPlatforms:
      - Linux_x64
      - Windows_NT_x64
      - OSX_x64
      liveRuntimeBuildConfig: release

#
# Libraries Build that only run when libraries is changed
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/libraries/build-job.yml
    buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
    platforms:
    - ${{ if eq(variables['isFullMatrix'], false) }}:
      - Windows_NT_x86
    jobParameters:
      liveRuntimeBuildConfig: release
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_libraries.containsChange'], true),
          eq(variables['isFullMatrix'], true))

- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/libraries/build-job.yml
    buildConfig: Release
    platforms:
    - Windows_NT_x86
    - ${{ if eq(variables['isFullMatrix'], true) }}:
      - Windows_NT_x64
    helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
    jobParameters:
      isFullMatrix: ${{ variables.isFullMatrix }}
      framework: net48
      runTests: true
      testScope: innerloop
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_libraries.containsChange'], true),
          eq(variables['isFullMatrix'], true))

- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/libraries/build-job.yml
    buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
    platforms:
    - Windows_NT_x64
    helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
    jobParameters:
      isFullMatrix: ${{ variables.isFullMatrix }}
      framework: allConfigurations
      runTests: true
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_libraries.containsChange'], true),
          eq(variables['isFullMatrix'], true))

#
# Installer Build and Test
# These are always built since they only take like 15 minutes
# we expect these to be done before we finish libraries or coreclr testing.
#
- template: /eng/pipelines/installer/installer-matrix.yml
  parameters:
    buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
    platforms:
      - Linux_arm
      - Linux_musl_arm64
      - Windows_NT_x86
      - Windows_NT_arm
      - Windows_NT_arm64
    jobParameters:
      liveRuntimeBuildConfig: release
      liveLibrariesBuildConfig: Release

- template: /eng/pipelines/installer/installer-matrix.yml
  parameters:
    buildConfig: Release
    platforms:
      - OSX_x64
      - Linux_x64
      - Linux_arm64
      - Linux_musl_x64
      - Windows_NT_x64
      - FreeBSD_x64
    jobParameters:
      liveRuntimeBuildConfig: release
      liveLibrariesBuildConfig: ${{ variables.debugOnPrReleaseOnRolling }}

#
# Crossgen-comparison jobs
# Only when CoreCLR is changed
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/coreclr/templates/crossgen-comparison-job.yml
    buildConfig: checked
    platforms:
    - Linux_arm
    helixQueueGroup: pr
    helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
    jobParameters:
      liveLibrariesBuildConfig: Release
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_coreclr.containsChange'], true),
          eq(variables['isFullMatrix'], true))

#
# CoreCLR Test builds using live libraries release build
# Only when CoreCLR is changed
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/common/templates/runtimes/build-test-job.yml
    buildConfig: checked
    platforms:
    - CoreClrTestBuildHost # Either OSX_x64 or Linux_x64
    jobParameters:
      testGroup: innerloop
      liveLibrariesBuildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_coreclr.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(variables['isFullMatrix'], true))

#
# CoreCLR Test executions using live libraries
# Only when CoreCLR is changed
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/common/templates/runtimes/run-test-job.yml
    buildConfig: checked
    platforms:
    - Linux_arm
    - Windows_NT_x86
    - Windows_NT_arm64
    helixQueueGroup: pr
    helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
    jobParameters:
      testGroup: innerloop
      liveLibrariesBuildConfig: Release
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_coreclr.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(variables['isFullMatrix'], true))

- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/common/templates/runtimes/run-test-job.yml
    buildConfig: checked
    platforms:
    - OSX_x64
    - Linux_x64
    - Linux_arm64
    - Windows_NT_x64
    helixQueueGroup: pr
    helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
    jobParameters:
      testGroup: innerloop
      liveLibrariesBuildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_coreclr.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(variables['isFullMatrix'], true))

#
# Mono Test builds with CoreCLR runtime tests using live libraries debug build
# Only when Mono is changed
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/common/templates/runtimes/build-test-job.yml
    buildConfig: release
    runtimeFlavor: mono
    platforms:
    - CoreClrTestBuildHost # Either OSX_x64 or Linux_x64
    jobParameters:
      testGroup: innerloop
      liveLibrariesBuildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
      liveRuntimeBuildConfig: release
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(variables['isFullMatrix'], true))

#
# Mono CoreCLR runtime Test executions using live libraries
# Only when Mono is changed
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/common/templates/runtimes/run-test-job.yml
    buildConfig: release
    runtimeFlavor: mono
    platforms:
    - OSX_x64
    - Linux_arm64
    helixQueueGroup: pr
    helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
    jobParameters:
      testGroup: innerloop
      liveLibrariesBuildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
      liveRuntimeBuildConfig: release
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(variables['isFullMatrix'], true))
#
# Mono CoreCLR runtime Test executions using live libraries and LLVM AOT
# Only when Mono is changed
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/common/templates/runtimes/run-test-job.yml
    buildConfig: release
    runtimeFlavor: mono
    platforms:
    - Linux_x64
    helixQueueGroup: pr
    helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
    jobParameters:
      testGroup: innerloop
      liveLibrariesBuildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
      liveRuntimeBuildConfig: release
      runtimeVariant: llvmaot
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(variables['isFullMatrix'], true))

#
# Libraries Release Test Execution against a release mono runtime.
# Only when libraries or mono changed
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/libraries/run-test-job.yml
    runtimeFlavor: mono
    buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
    platforms:
    - Windows_NT_x64
    - OSX_x64
    - Linux_arm64
    - Linux_x64
    helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
    jobParameters:
      isOfficialBuild: false
      isFullMatrix: ${{ variables.isFullMatrix }}
      runtimeDisplayName: mono
      testScope: innerloop
      liveRuntimeBuildConfig: release
      dependsOnTestBuildConfiguration: ${{ variables.debugOnPrReleaseOnRolling }}
      dependsOnTestArchitecture: x64
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_mono.containsChange'], true),
          eq(variables['isFullMatrix'], true))

#
# Libraries Release Test Execution against a release mono interpreter runtime.
# Only when libraries or mono changed
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/libraries/run-test-job.yml
    runtimeFlavor: mono
    buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
    platforms:
    # - Windows_NT_x64
    #- OSX_x64
    - Linux_x64
    helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
    jobParameters:
      isOfficialBuild: false
      isFullMatrix: ${{ variables.isFullMatrix }}
      interpreter: true
      runtimeDisplayName: mono_interpreter
      testScope: innerloop
      liveRuntimeBuildConfig: release
      dependsOnTestBuildConfiguration: ${{ variables.debugOnPrReleaseOnRolling }}
      dependsOnTestArchitecture: x64
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_mono.containsChange'], true),
          eq(variables['isFullMatrix'], true))

#
# Libraries Release Test Execution against a release coreclr runtime
# Only when the PR contains a libraries change
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/libraries/run-test-job.yml
    buildConfig: Release
    platforms:
    - Windows_NT_x86
    - ${{ if eq(variables['isFullMatrix'], true) }}:
      - Windows_NT_arm64
    helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
    jobParameters:
      isOfficialBuild: false
      isFullMatrix: ${{ variables.isFullMatrix }}
      testScope: innerloop
      liveRuntimeBuildConfig: release
      dependsOnTestBuildConfiguration: ${{ variables.debugOnPrReleaseOnRolling }}
      dependsOnTestArchitecture: x64
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_libraries.containsChange'], true),
          eq(variables['isFullMatrix'], true))

#
# Libraries Debug Test Execution against a release coreclr runtime
# Only when the PR contains a libraries change
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/libraries/run-test-job.yml
    buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
    platforms:
    - Windows_NT_x64
    - OSX_x64
    - Linux_x64
    - Linux_musl_x64
    - ${{ if eq(variables['isFullMatrix'], true) }}:
      - Linux_arm64
    - ${{ if eq(variables['isFullMatrix'], false) }}:
      - Windows_NT_x86
    helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
    jobParameters:
      isOfficialBuild: false
      isFullMatrix: ${{ variables.isFullMatrix }}
      testScope: innerloop
      liveRuntimeBuildConfig: release
      dependsOnTestBuildConfiguration: ${{ variables.debugOnPrReleaseOnRolling }}
      dependsOnTestArchitecture: x64
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_libraries.containsChange'], true),
          eq(variables['isFullMatrix'], true))

#
# Libraries Test Execution against a checked runtime
# Only when the PR contains a coreclr change
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/libraries/run-test-job.yml
    buildConfig: Release
    platforms:
    # - Windows_NT_arm return this when https://github.com/dotnet/runtime/issues/1097 is fixed.
    - Linux_arm
    - Linux_musl_arm64
    - Windows_NT_x86
    helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
    helixQueueGroup: libraries
    jobParameters:
      testScope: innerloop
      liveRuntimeBuildConfig: checked
      dependsOnTestBuildConfiguration: ${{ variables.debugOnPrReleaseOnRolling }}
      dependsOnTestArchitecture: x64
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_coreclr.containsChange'], true),
          eq(variables['isFullMatrix'], true))

- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/libraries/run-test-job.yml
    buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
    platforms:
    - Windows_NT_x64
    - Linux_x64
    - Linux_musl_x64
    helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
    helixQueueGroup: libraries
    jobParameters:
      testScope: innerloop
      liveRuntimeBuildConfig: checked
      dependsOnTestBuildConfiguration: ${{ variables.debugOnPrReleaseOnRolling }}
      dependsOnTestArchitecture: x64
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_coreclr.containsChange'], true),
          eq(variables['isFullMatrix'], true))

#
# Libraries Test Execution against a checked runtime
# Only if CoreCLR or Libraries is changed
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/libraries/run-test-job.yml
    buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
    platforms:
    - OSX_x64
    helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
    helixQueueGroup: libraries
    jobParameters:
      testScope: innerloop
      liveRuntimeBuildConfig: checked
      dependsOnTestBuildConfiguration: ${{ variables.debugOnPrReleaseOnRolling }}
      dependsOnTestArchitecture: x64
      condition: >-
        or(
          eq(dependencies.checkout.outputs['SetPathVars_coreclr.containsChange'], true),
          eq(dependencies.checkout.outputs['SetPathVars_libraries.containsChange'], true),
          eq(variables['isFullMatrix'], true))