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:
    - release/*.*
  paths:
    include:
    - '*'
    exclude:
    - '**.md'
    - eng/Version.Details.xml
    - .devcontainer/*
    - .github/*
    - docs/*
    - LICENSE.TXT
    - PATENTS.TXT
    - THIRD-PARTY-NOTICES.TXT
    - eng/pipelines/performance/*
    - eng/testing/performance/*

schedules:
  - cron: "0 8,20 * * *" # run at 8:00 and 20:00 (UTC) which is 00:00 and 12:00 (PST).
    displayName: Runtime default schedule
    branches:
      include:
      - main
    always: false # run only if there were changes since the last successful scheduled run.

pr:
  branches:
    include:
    - main
    - release/*.*
  paths:
    include:
    - '*'
    exclude:
    - '**.md'
    - eng/Version.Details.xml
    - .devcontainer/*
    - .github/*
    - docs/*
    - LICENSE.TXT
    - PATENTS.TXT
    - THIRD-PARTY-NOTICES.TXT

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

extends:
  template:  /eng/pipelines/common/templates/pipeline-with-resources.yml
  parameters:
    isOfficialBuild: false
    stages:
    - ${{ if eq(variables['Build.Reason'], 'PullRequest') }}:
      - stage: EvaluatePaths
        displayName: Evaluate Paths
        jobs:
          - template: /eng/pipelines/common/evaluate-default-paths.yml

    - stage: Build
      jobs:

      #
      # Build CoreCLR verticals where we don't run host tests
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
          - linux_musl_arm
          - linux_musl_arm64
          - windows_arm64
          - linux_arm
          jobParameters:
            nameSuffix: AllSubsets_CoreCLR_ReleaseRuntimeLibs
            buildArgs: -s clr+libs+host+packs -rc Release -lc Release -c $(_BuildConfig)
            timeoutInMinutes: 120
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_non_mono_and_wasm.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
          - osx_arm64
          jobParameters:
            nameSuffix: AllSubsets_CoreCLR
            buildArgs: -s clr+libs+host+packs -rc Release -c Release -lc $(_BuildConfig)
            timeoutInMinutes: 120
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_non_mono_and_wasm.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
          - linux_arm64
          - linux_musl_x64
          jobParameters:
            nameSuffix: AllSubsets_CoreCLR
            buildArgs: -s clr+libs+host+packs -rc Release -c Release -lc $(_BuildConfig)
            timeoutInMinutes: 120
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_non_mono_and_wasm.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
          - browser_wasm
          jobParameters:
            nameSuffix: AllSubsets_CoreCLR
            buildArgs: -s clr.runtime -rc Release -c Release -lc $(_BuildConfig)
            timeoutInMinutes: 120
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_non_mono_and_wasm.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build CoreCLR and Libraries with Libraries tests
      # For running libraries tests and installer tests
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
          - linux_x64
          - linux_musl_x64
          - osx_x64
          - windows_x64
          jobParameters:
            nameSuffix: CoreCLR_Libraries
            buildArgs: -s clr+libs+libs.tests -rc Release -c $(_BuildConfig) /p:ArchiveTests=true
            timeoutInMinutes: 120
            postBuildSteps:
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/bin
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: CoreCLR_Libraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
                  displayName: Build Assets
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/helix
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: CoreCLR_Libraries_TestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_non_mono_and_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: release
          platforms:
          - windows_x86
          jobParameters:
            nameSuffix: CoreCLR_Libraries
            buildArgs: -s clr+libs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true
            timeoutInMinutes: 120
            postBuildSteps:
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/bin
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: CoreCLR_Libraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
                  displayName: Build Assets
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/helix
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: CoreCLR_Libraries_TestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_non_mono_and_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build CoreCLR and Libraries with the respective tests
      # for the test configurations we run.
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
          - linux_arm64
          - osx_x64
          jobParameters:
            nameSuffix: Libraries_CheckedCoreCLR
            buildArgs: -s clr+libs+libs.tests -c $(_BuildConfig) -rc Checked /p:ArchiveTests=true
            timeoutInMinutes: 120
            postBuildSteps:
              - template: /eng/pipelines/coreclr/templates/build-native-test-assets-step.yml
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/bin
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: Libraries_CheckedCoreCLR_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
                  displayName: Build Assets
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/helix
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: Libraries_CheckedCoreCLR_TestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            extraVariablesTemplates:
              - template: /eng/pipelines/common/templates/runtimes/native-test-assets-variables.yml
                parameters:
                  testGroup: innerloop
                  configOverride: Checked
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
          - linux_x64
          - windows_x64
          jobParameters:
            nameSuffix: Libraries_CheckedCoreCLR
            buildArgs: -s clr+libs -c $(_BuildConfig) -rc Checked
            timeoutInMinutes: 120
            postBuildSteps:
              - template: /eng/pipelines/coreclr/templates/build-native-test-assets-step.yml
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/bin
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: Libraries_CheckedCoreCLR_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
                  displayName: Build Assets
            extraVariablesTemplates:
              - template: /eng/pipelines/common/templates/runtimes/native-test-assets-variables.yml
                parameters:
                  testGroup: innerloop
                  configOverride: Checked
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
          - linux_musl_x64
          - windows_x86
          jobParameters:
            nameSuffix: Libraries_CheckedCoreCLR
            buildArgs: -s clr+libs+libs.tests -c $(_BuildConfig) -rc Checked /p:ArchiveTests=true
            timeoutInMinutes: 120
            postBuildSteps:
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/bin
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: Libraries_CheckedCoreCLR_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
                  displayName: Build Assets
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/helix
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: Libraries_CheckedCoreCLR_TestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
          - osx_arm64
          jobParameters:
            nameSuffix: Libraries_CheckedCoreCLR
            buildArgs: -s clr+libs -c $(_BuildConfig) -rc Checked
            timeoutInMinutes: 120
            postBuildSteps:
              - template: /eng/pipelines/coreclr/templates/build-native-test-assets-step.yml
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/bin
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: Libraries_CheckedCoreCLR_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
                  displayName: Build Assets
            extraVariablesTemplates:
              - template: /eng/pipelines/common/templates/runtimes/native-test-assets-variables.yml
                parameters:
                  testGroup: innerloop
                  configOverride: Checked
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr_AppleSilicon.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: checked
          platforms:
          - linux_arm
          - windows_arm64
          - windows_x86
          jobParameters:
            nameSuffix: CoreCLR_ReleaseLibraries
            buildArgs: -s clr+libs -rc $(_BuildConfig) -c Release
            timeoutInMinutes: 120
            postBuildSteps:
              - template: /eng/pipelines/coreclr/templates/build-native-test-assets-step.yml
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/bin
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: CoreCLR_ReleaseLibraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
                  displayName: Build Assets
            extraVariablesTemplates:
              - template: /eng/pipelines/common/templates/runtimes/native-test-assets-variables.yml
                parameters:
                  testGroup: innerloop
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: checked
          platforms:
          - linux_x64
          - linux_musl_arm
          - linux_musl_arm64
          - windows_x64
          jobParameters:
            nameSuffix: CoreCLR_ReleaseLibraries
            buildArgs: -s clr+libs+libs.tests -rc $(_BuildConfig) -c Release /p:ArchiveTests=true
            timeoutInMinutes: 120
            postBuildSteps:
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/bin
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: CoreCLR_ReleaseLibraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
                  displayName: Build Assets
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/helix
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: CoreCLR_ReleaseLibraries_TestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build the whole product using GNU compiler toolchain
      # When CoreCLR, Mono, Libraries, Installer and src/tests are changed
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: checked
          platforms:
          - gcc_linux_x64
          jobParameters:
            testGroup: innerloop
            nameSuffix: Native_GCC
            buildArgs: -s clr.native+libs.native+mono+host.native -c $(_BuildConfig) -gcc
            postBuildSteps:
              - template: /eng/pipelines/common/templates/runtimes/build-runtime-tests.yml
                parameters:
                  testBuildArgs: skipmanaged skipgeneratelayout skiprestorepackages -gcc
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build CoreCLR and run crossgen on S.P.CoreLib
      #
      - 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: checked
          runtimeFlavor: coreclr
          platforms:
          - linux_x86
          jobParameters:
            testScope: innerloop
            nameSuffix: CoreCLR
            buildArgs: -s clr.runtime+clr.jit+clr.iltools+clr.spmi+clr.corelib+clr.nativecorelib -c $(_BuildConfig)
            timeoutInMinutes: 120
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build CoreCLR as a non-portable build
      #
      - 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: checked
          runtimeFlavor: coreclr
          platforms:
          - tizen_armel
          jobParameters:
            testScope: innerloop
            nameSuffix: CoreCLR_NonPortable
            buildArgs: -s clr.native+clr.tools+clr.corelib+clr.nativecorelib+clr.aot+clr.packages --outputrid tizen.9.0.0-armel -c $(_BuildConfig) /p:PortableBuild=false
            timeoutInMinutes: 120
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build CoreCLR + Libs + Host
      #
      - 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: ${{ variables.debugOnPrReleaseOnRolling }}
          runtimeFlavor: coreclr
          platforms:
          - freebsd_x64
          - linux_riscv64
          - linux_loongarch64
          jobParameters:
            testScope: innerloop
            nameSuffix: CoreCLR_TwoStage
            buildArgs: -s clr+libs+host -c $(_BuildConfig) -rc Checked -p:StageOneBuild=true
            timeoutInMinutes: 120
            postBuildSteps:
              - script: |
                  echo Running $(Build.SourcesDirectory)/build$(scriptExt)  \
                    ${{ variables.debugOnPrReleaseOnRolling }}              \
                    -s clr.tools+packs -rc Checked -cross                   \
                    -os $(osGroup)                                          \
                    -a $(archType)                                          \
                    -c $(_BuildConfig)                                      \
                    -p:StageTwoBuild=true

                  $(Build.SourcesDirectory)/build$(scriptExt)  \
                    ${{ variables.debugOnPrReleaseOnRolling }} \
                    -s clr.tools+packs -rc Checked -cross      \
                    -os $(osGroup)                             \
                    -a $(archType)                             \
                    -c $(_BuildConfig)                         \
                    -p:StageTwoBuild=true
                displayName: Build clr.tools and packs
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # CoreCLR NativeAOT debug build and smoke tests
      # Only when CoreCLR is changed
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          buildConfig: Debug
          platforms:
          - linux_x64
          - windows_x64
          variables:
          - name: timeoutPerTestInMinutes
            value: 60
          - name: timeoutPerTestCollectionInMinutes
            value: 180
          jobParameters:
            timeoutInMinutes: 120
            nameSuffix: NativeAOT
            buildArgs: -s clr.aot+libs -rc $(_BuildConfig) -lc Release /p:RunAnalyzers=false
            postBuildSteps:
              - template: /eng/pipelines/coreclr/nativeaot-post-build-steps.yml
                parameters:
                  creator: dotnet-bot
                  testBuildArgs: nativeaot tree nativeaot
                  liveLibrariesBuildConfig: Release
                  testRunNamePrefixSuffix: NativeAOT_$(_BuildConfig)
            extraVariablesTemplates:
              - template: /eng/pipelines/common/templates/runtimes/test-variables.yml
                parameters:
                  testGroup: innerloop
                  liveLibrariesBuildConfig: Release
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_tools_illink.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # CoreCLR NativeAOT checked build and smoke tests
      # Only when CoreCLR is changed
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          buildConfig: Checked
          platforms:
          - windows_x64
          variables:
          - name: timeoutPerTestInMinutes
            value: 60
          - name: timeoutPerTestCollectionInMinutes
            value: 180
          jobParameters:
            timeoutInMinutes: 180
            nameSuffix: NativeAOT
            buildArgs: -s clr.aot+libs.native+libs.sfx -rc $(_BuildConfig) -lc Release /p:RunAnalyzers=false
            postBuildSteps:
              - template: /eng/pipelines/coreclr/nativeaot-post-build-steps.yml
                parameters:
                  creator: dotnet-bot
                  testBuildArgs: 'nativeaot tree ";nativeaot;Loader;Interop;JIT/HardwareIntrinsics;" /p:BuildNativeAotFrameworkObjects=true'
                  liveLibrariesBuildConfig: Release
                  testRunNamePrefixSuffix: NativeAOT_$(_BuildConfig)
            extraVariablesTemplates:
              - template: /eng/pipelines/common/templates/runtimes/test-variables.yml
                parameters:
                  testGroup: innerloop
                  liveLibrariesBuildConfig: Release
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_tools_illink.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # CoreCLR NativeAOT release build and smoke tests
      # Only when CoreCLR is changed
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          buildConfig: Release
          platforms:
          - linux_x64
          - windows_x64
          - osx_x64
          - linux_arm64
          - windows_arm64
          variables:
          - name: timeoutPerTestInMinutes
            value: 60
          - name: timeoutPerTestCollectionInMinutes
            value: 180
          jobParameters:
            testGroup: innerloop
            timeoutInMinutes: 120
            nameSuffix: NativeAOT
            buildArgs: -s clr.aot+libs+tools.illink -c $(_BuildConfig) -rc $(_BuildConfig) -lc Release /p:RunAnalyzers=false
            postBuildSteps:
              - template: /eng/pipelines/coreclr/nativeaot-post-build-steps.yml
                parameters:
                  creator: dotnet-bot
                  testBuildArgs: 'nativeaot tree ";nativeaot;tracing/eventpipe/providervalidation;"'
                  liveLibrariesBuildConfig: Release
                  testRunNamePrefixSuffix: NativeAOT_$(_BuildConfig)
            extraVariablesTemplates:
              - template: /eng/pipelines/common/templates/runtimes/test-variables.yml
                parameters:
                  testGroup: innerloop
                  liveLibrariesBuildConfig: Release
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_tools_illink.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # CoreCLR NativeAOT release build and libraries tests
      # Only when CoreCLR or library is changed
      #
      - 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
          platforms:
          - windows_arm64
          - linux_arm64
          - osx_arm64
          jobParameters:
            testGroup: innerloop
            isSingleFile: true
            nameSuffix: NativeAOT_Libraries
            buildArgs: -s clr.aot+libs+libs.tests -c $(_BuildConfig) /p:TestNativeAot=true /p:RunSmokeTestsOnly=true /p:ArchiveTests=true /p:RunAnalyzers=false
            timeoutInMinutes: 240 # Doesn't actually take long, but we've seen the ARM64 Helix queue often get backlogged for 2+ hours
            # extra steps, run tests
            postBuildSteps:
              - template: /eng/pipelines/libraries/helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: NativeAOT_$(_BuildConfig)
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_tools_illink.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      # Build and test clr tools
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: checked
          platforms:
          - linux_x64
          jobParameters:
            timeoutInMinutes: 120
            nameSuffix: CLR_Tools_Tests
            buildArgs: -s clr.aot+clr.iltools+libs.sfx+clr.toolstests+tools.cdac+tools.cdactests -c $(_BuildConfig) -test
            enablePublishTestResults: true
            testResultsFormat: 'xunit'
            # We want to run AOT tests when illink changes because there's share code and tests from illink which are used by AOT
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_tools_illink.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_tools_cdac.containsChange'], true),
                eq(variables['isRollingBuild'], true))
      #
      # Build CrossDacs
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: release
          platforms:
          - windows_x64
          variables:
            - name: _archParameter
              value: -arch x64,x86,arm,arm64
          jobParameters:
            buildArgs: -s linuxdac+alpinedac -c Checked,$(_BuildConfig)
            nameSuffix: CrossDac
            isOfficialBuild: false
            timeoutInMinutes: 60
            postBuildSteps:
            - publish: $(Build.SourcesDirectory)/artifacts/bin/coreclr
              displayName: Publish CrossDacs for diagnostics
              artifact: CoreCLRCrossDacArtifacts
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_non_mono_and_wasm.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      # Build Mono AOT offset headers once, for validation
      # Only when mono changed
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: release
          platforms:
          - android_x64
          - browser_wasm
          - wasi_wasm
          - ios_arm64 # tvos and ios use the same offsets so we only need to build once
          - maccatalyst_x64
          variables:
            - name: _osParameter
              value: -os linux
            - name: _archParameter
              value: -arch x64
          jobParameters:
            nameSuffix: MonoAOTOffsets
            buildArgs: -s mono.aotcross -c $(_BuildConfig) /p:MonoGenerateOffsetsOSGroups=$(osGroup) /p:ValidateMonoOffsets=true
            postBuildSteps:
              # Upload offset files
              - task: CopyFiles@2
                displayName: Collect offset files
                condition: failed()
                inputs:
                  sourceFolder: '$(Build.SourcesDirectory)/src/mono/mono/offsets'
                  contents: '*.h.new'
                  targetFolder: '$(Build.SourcesDirectory)/artifacts/obj/mono/offsetfiles/'

              - publish: '$(Build.SourcesDirectory)/artifacts/obj/mono/offsetfiles'
                condition: failed()
                artifact: MonoAOTOffsets_$(osGroup)$(osSubGroup)
                displayName: Upload offset files
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], 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:
          - tvossimulator_x64
          - linux_x64
          - linux_arm
          - linux_arm64
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_Mono
            buildArgs: -s mono+libs+host+packs -c $(_BuildConfig)
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: Release
          runtimeFlavor: mono
          platforms:
          - linux_musl_x64
          - osx_x64
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_Mono
            buildArgs: -s mono+libs+host+packs -c $(_BuildConfig)
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # WebAssembly legs
      #
      - template: /eng/pipelines/common/templates/wasm-library-tests.yml
        parameters:
          platforms:
            - browser_wasm
          alwaysRun: ${{ variables.isRollingBuild }}
          extraBuildArgs: /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS)
          scenarios:
            - WasmTestOnChrome
            - WasmTestOnFirefox

      - template: /eng/pipelines/common/templates/wasm-library-tests.yml
        parameters:
          platforms:
            - browser_wasm_win
          alwaysRun: ${{ variables.isRollingBuild }}
          extraBuildArgs: /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS)
          scenarios:
            - WasmTestOnChrome

      # EAT Library tests - only run on linux
      - template: /eng/pipelines/common/templates/wasm-library-aot-tests.yml
        parameters:
          platforms:
            - browser_wasm
          nameSuffix: _EAT
          runAOT: false
          shouldRunSmokeOnly: false
          alwaysRun: ${{ variables.isRollingBuild }}
          extraBuildArgs: /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS) /maxcpucount:2

      # AOT Library tests
      - template: /eng/pipelines/common/templates/wasm-library-aot-tests.yml
        parameters:
          platforms:
            - browser_wasm
            - browser_wasm_win
          nameSuffix: _Smoke_AOT
          runAOT: true
          shouldRunSmokeOnly: true
          alwaysRun: ${{ variables.isRollingBuild }}
          extraBuildArgs: /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS)

      # For Wasm.Build.Tests - runtime pack builds
      - template: /eng/pipelines/common/templates/wasm-build-only.yml
        parameters:
          platforms:
            - browser_wasm
            - browser_wasm_win
          condition: or(eq(variables.isRollingBuild, true), eq(variables.wasmSingleThreadedBuildOnlyNeededOnDefaultPipeline, true))
          nameSuffix: SingleThreaded
          extraBuildArgs: /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS)
          publishArtifactsForWorkload: true
          publishWBT: true

      - template: /eng/pipelines/common/templates/wasm-build-only.yml
        parameters:
          platforms:
            - browser_wasm
            - browser_wasm_win
          condition: or(eq(variables.isRollingBuild, true), eq(variables.wasmSingleThreadedBuildOnlyNeededOnDefaultPipeline, true))
          nameSuffix: MultiThreaded
          extraBuildArgs: /p:WasmEnableThreads=true /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS)
          publishArtifactsForWorkload: true
          publishWBT: false

      # Browser Wasm.Build.Tests
      - template: /eng/pipelines/common/templates/browser-wasm-build-tests.yml
        parameters:
          platforms:
            - browser_wasm
            - browser_wasm_win
          alwaysRun: ${{ variables.isRollingBuild }}
          extraBuildArgs: /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS)

      # Wasm runtime tests
      - template: /eng/pipelines/common/templates/wasm-runtime-tests.yml
        parameters:
          platforms:
            - browser_wasm
          alwaysRun: ${{ variables.isRollingBuild }}
          extraBuildArgs: /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS)

      # WASI/WASM

      - template: /eng/pipelines/common/templates/simple-wasm-build-tests.yml
        parameters:
          platforms:
            - wasi_wasm
            - wasi_wasm_win
          extraBuildArgs: /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS)
          alwaysRun: ${{ variables.isRollingBuild }}

      #
      # Android devices
      # Build the whole product using Mono and run libraries 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:
          - android_arm
          - android_arm64
          variables:
            # map dependencies variables to local variables
            - name: librariesContainsChange
              value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
            - name: monoContainsChange
              value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'] ]
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_Mono
            buildArgs: -s mono+libs+libs.tests+host+packs -c $(_BuildConfig) /p:ArchiveTests=true /p:RunSmokeTestsOnly=true /p:EnableAdditionalTimezoneChecks=true
            timeoutInMinutes: 480
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], true))
            # extra steps, run tests
            postBuildSteps:
              - template: /eng/pipelines/libraries/helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: Mono_$(_BuildConfig)
                  condition: >-
                    or(
                    eq(variables['librariesContainsChange'], true),
                    eq(variables['monoContainsChange'], true),
                    eq(variables['isRollingBuild'], true))

      #
      # Android arm64 devices and x64 emulators
      # Build the whole product using CoreCLR and run functional 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: coreclr
          platforms:
          - android_x64
          - android_arm64
          variables:
            # map dependencies variables to local variables
            - name: librariesContainsChange
              value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
            - name: coreclrContainsChange
              value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'] ]
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_CoreCLR
            buildArgs: -s clr.runtime+clr.alljits+clr.corelib+clr.nativecorelib+clr.tools+clr.packages+libs++libs.tests+host+packs -c $(_BuildConfig) /p:ArchiveTests=true /p:TestAssemblies=false
            timeoutInMinutes: 480
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], true))
            # extra steps, run tests
            postBuildSteps:
              - template: /eng/pipelines/libraries/helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: CoreCLR_$(_BuildConfig)
                  condition: >-
                    or(
                    eq(variables['librariesContainsChange'], true),
                    eq(variables['coreclrContainsChange'], true),
                    eq(variables['isRollingBuild'], true))

      #
      # iOS/tvOS devices - Full AOT + AggressiveTrimming to reduce size
      # Build the whole product using Mono and run libraries 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:
            - ios_arm64
            - tvos_arm64
          variables:
            # map dependencies variables to local variables
            - name: librariesContainsChange
              value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
            - name: monoContainsChange
              value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'] ]
            - name: illinkContainsChange
              value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_tools_illink.containsChange'] ]
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_Mono
            buildArgs: -s mono+libs+libs.tests+host+packs -c $(_BuildConfig) /p:ArchiveTests=true /p:DevTeamProvisioning=- /p:RunAOTCompilation=true /p:RunSmokeTestsOnly=true /p:BuildTestsOnHelix=true /p:EnableAdditionalTimezoneChecks=true /p:UsePortableRuntimePack=false /p:EnableAggressiveTrimming=true
            timeoutInMinutes: 480
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_tools_illink.containsChange'], true),
                eq(variables['isRollingBuild'], true))
            # extra steps, run tests
            postBuildSteps:
              - template: /eng/pipelines/libraries/helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: Mono_$(_BuildConfig)
                  extraHelixArguments: /p:NeedsToBuildAppsOnHelix=true
                  condition: >-
                    or(
                    eq(variables['librariesContainsChange'], true),
                    eq(variables['monoContainsChange'], true),
                    eq(variables['illinkContainsChange'], true),
                    eq(variables['isRollingBuild'], true))

      #
      # iOS/tvOS devices
      # Build the whole product using Native AOT and run libraries 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: coreclr
          platforms:
            - ios_arm64
            - tvos_arm64
          variables:
            # map dependencies variables to local variables
            - name: librariesContainsChange
              value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
            - name: coreclrContainsChange
              value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'] ]
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_NativeAOT
            buildArgs: --cross -s clr.alljits+clr.tools+clr.nativeaotruntime+clr.nativeaotlibs+libs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true /p:RunSmokeTestsOnly=true /p:DevTeamProvisioning=- /p:BuildTestsOnHelix=true /p:UseNativeAOTRuntime=true /p:RunAOTCompilation=false /p:ContinuousIntegrationBuild=true
            timeoutInMinutes: 180
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], true))
            # extra steps, run tests
            postBuildSteps:
              - template: /eng/pipelines/libraries/helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: NativeAOT_$(_BuildConfig)
                  extraHelixArguments: /p:NeedsToBuildAppsOnHelix=true
                  condition: >-
                    or(
                    eq(variables['librariesContainsChange'], true),
                    eq(variables['coreclrContainsChange'], true),
                    eq(variables['isRollingBuild'], true))

      #
      # MacCatalyst interp - requires AOT Compilation and Interp flags
      # Build the whole product using Mono and run libraries 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:
          - maccatalyst_x64
          - maccatalyst_arm64
          variables:
            # map dependencies variables to local variables
            - name: librariesContainsChange
              value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
            - name: monoContainsChange
              value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'] ]
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_Mono
            buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true /p:RunSmokeTestsOnly=true /p:DevTeamProvisioning=adhoc /p:RunAOTCompilation=true /p:MonoForceInterpreter=true
            timeoutInMinutes: 180
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], true))
            # extra steps, run tests
            postBuildSteps:
              - template: /eng/pipelines/libraries/helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: Mono_$(_BuildConfig)
                  condition: >-
                    or(
                      eq(variables['librariesContainsChange'], true),
                      eq(variables['monoContainsChange'], true),
                      eq(variables['isRollingBuild'], 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+host+packs -c $(_BuildConfig)
                      /p:MonoEnableLLVM=true /p:MonoAOTEnableLLVM=true /p:MonoBundleLLVMOptimizer=true
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], 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+host+packs -c $(_BuildConfig)
                      /p:MonoEnableLLVM=true /p:MonoAOTEnableLLVM=true /p:MonoBundleLLVMOptimizer=true
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build Mono debug
      # Only when mono changed
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          runtimeFlavor: mono
          buildConfig: debug
          platforms:
          - osx_x64
          - osx_arm64
          - linux_x64
          - linux_arm64
          # - linux_musl_arm64
          - windows_x64
          - windows_x86
          # - windows_arm64
          jobParameters:
            nameSuffix: Mono_Runtime
            buildArgs: -s mono -c $(_BuildConfig)
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build Mono release AOT cross-compilers
      # Only when mono changed
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          runtimeFlavor: mono
          buildConfig: release
          platforms:
          - linux_x64
          - linux_musl_x64
          - linux_arm64
          - linux_musl_arm64
          - windows_arm64
          - windows_x64
          - osx_x64
          - osx_arm64
          jobParameters:
            buildArgs: -c $(_BuildConfig) /p:DotNetBuildMonoCrossAOT=true
            nameSuffix: CrossAOT_Mono
            runtimeVariant: crossaot
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build and test libraries for .NET Framework
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: Release
          platforms:
          - windows_x86
          helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
          jobParameters:
            framework: net481
            buildArgs: -s tools+libs+libs.tests -framework net481 -c $(_BuildConfig) -testscope innerloop /p:ArchiveTests=true
            nameSuffix: Libraries_NET481
            timeoutInMinutes: 150
            postBuildSteps:
              - template: /eng/pipelines/libraries/helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: NET481_$(_BuildConfig)
                  extraHelixArguments: /p:BuildTargetFramework=net481
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build and test libraries for all TFMs and create packages
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
          - windows_x64
          jobParameters:
            buildArgs: -test -s tools.illink+libs+libs.tests -pack -c $(_BuildConfig) /p:TestAssemblies=false /p:TestPackages=true
            nameSuffix: Libraries_WithPackages
            timeoutInMinutes: 150
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_tools_illink.containsChange'], true),
                eq(variables['isRollingBuild'], 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/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
            - windows_x86
          jobParameters:
            nameSuffix: Installer_Build_And_Test
            buildArgs: -s host+packs -c $(_BuildConfig) -lc Release -rc Release -test
            dependsOnGlobalBuilds:
              - nameSuffix: CoreCLR_Libraries
                buildConfig: release
            preBuildSteps:
              - template: /eng/pipelines/common/download-artifact-step.yml
                parameters:
                  artifactName: CoreCLR_Libraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_Release
                  artifactFileName: CoreCLR_Libraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_Release$(archiveExtension)
                  unpackFolder: $(Build.SourcesDirectory)/artifacts/bin
                  displayName: 'unified artifacts'
            enablePublishTestResults: true
            testRunTitle: Installer-$(osGroup)$(osSubgroup)_$(archType)
            postBuildSteps:
              - template: /eng/pipelines/installer/steps/upload-job-artifacts.yml
                parameters:
                  name: $(osGroup)$(osSubgroup)_$(archType)
            condition:
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_non_mono_and_wasm.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: release
          platforms:
            - windows_x64
            - osx_x64
            - linux_x64
          jobParameters:
            nameSuffix: Installer_Build_And_Test
            buildArgs: -s host+packs -c $(_BuildConfig) -lc ${{ variables.debugOnPrReleaseOnRolling }} -rc Release -test
            dependsOnGlobalBuilds:
              - nameSuffix: CoreCLR_Libraries
                buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
            preBuildSteps:
              - template: /eng/pipelines/common/download-artifact-step.yml
                parameters:
                  artifactName: CoreCLR_Libraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(debugOnPrReleaseOnRolling)
                  artifactFileName: CoreCLR_Libraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(debugOnPrReleaseOnRolling)$(archiveExtension)
                  unpackFolder: $(Build.SourcesDirectory)/artifacts/bin
                  displayName: 'unified artifacts'
            enablePublishTestResults: true
            testRunTitle: Installer-$(osGroup)$(osSubgroup)_$(archType)
            postBuildSteps:
              - template: /eng/pipelines/installer/steps/upload-job-artifacts.yml
                parameters:
                  name: $(osGroup)$(osSubgroup)_$(archType)
            condition:
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_non_mono_and_wasm.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build the whole product using Mono and run runtime tests
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          buildConfig: Release
          runtimeFlavor: mono
          platforms:
            - osx_x64
            - linux_arm64
          variables:
            - name: timeoutPerTestInMinutes
              value: 60
            - name: timeoutPerTestCollectionInMinutes
              value: 180
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_Mono_Minijit_RuntimeTests
            runtimeVariant: minijit
            buildArgs: -s mono+libs+clr.hosts+clr.iltools -c Release
            timeoutInMinutes: 180
            condition: >-
                  or(
                    eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                    eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                    eq(variables['isRollingBuild'], true))

            postBuildSteps:
              - template: /eng/pipelines/common/templates/runtimes/build-runtime-tests-and-send-to-helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: Mono_Release
            extraVariablesTemplates:
              - template: /eng/pipelines/common/templates/runtimes/test-variables.yml

      #
      # Build the whole product using Mono and run runtime tests
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          buildConfig: Release
          runtimeFlavor: mono
          platforms:
            - windows_x64
          variables:
            - name: timeoutPerTestInMinutes
              value: 60
            - name: timeoutPerTestCollectionInMinutes
              value: 180
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_Mono_Minijit_RuntimeTests
            runtimeVariant: minijit
            buildArgs: -s mono+libs+clr.hosts+clr.iltools -c Release -lc ${{ variables.debugOnPrReleaseOnRolling }}
            timeoutInMinutes: 180
            condition: >-
                  or(
                    eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                    eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                    eq(variables['isRollingBuild'], true))

            postBuildSteps:
              - template: /eng/pipelines/common/templates/runtimes/build-runtime-tests-and-send-to-helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: Mono_Release
            extraVariablesTemplates:
              - template: /eng/pipelines/common/templates/runtimes/test-variables.yml
                parameters:
                  liveLibrariesBuildConfig: ${{ variables.debugOnPrReleaseOnRolling }}

      #
      # Mono CoreCLR runtime Test executions using live libraries in interpreter mode
      # Only when Mono is changed

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          buildConfig: Release
          runtimeFlavor: mono
          platforms:
            - osx_x64
          variables:
            - name: timeoutPerTestInMinutes
              value: 60
            - name: timeoutPerTestCollectionInMinutes
              value: 180
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_Mono_Interpreter_RuntimeTests
            runtimeVariant: monointerpreter
            buildArgs: -s mono+libs+clr.hosts+clr.iltools -c Release
            timeoutInMinutes: 180
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(variables['isRollingBuild'], true))
            postBuildSteps:
              - template: /eng/pipelines/common/templates/runtimes/build-runtime-tests-and-send-to-helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: Mono_Release
            extraVariablesTemplates:
              - template: /eng/pipelines/common/templates/runtimes/test-variables.yml
      #
      # 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/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          buildConfig: Release
          runtimeFlavor: mono
          platforms:
            - linux_x64
            # Disabled pending outcome of https://github.com/dotnet/runtime/issues/60234 investigation
            #- linux_arm64
          variables:
            - name: timeoutPerTestInMinutes
              value: 60
            - name: timeoutPerTestCollectionInMinutes
              value: 180
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_Mono_LLVMAot_RuntimeTests
            runtimeVariant: llvmaot
            buildArgs: -s mono+libs+clr.hosts+clr.iltools -c Release /p:MonoEnableLLVM=true /p:MonoAOTEnableLLVM=true /p:MonoBundleLLVMOptimizer=true
            timeoutInMinutes: 180

            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(variables['isRollingBuild'], true))
            postBuildSteps:
              - template: /eng/pipelines/common/templates/runtimes/build-runtime-tests-and-send-to-helix.yml
                parameters:
                  creator: dotnet-bot
                  llvmAotStepContainer: linux_x64_llvmaot
                  testRunNamePrefixSuffix: Mono_Release
            extraVariablesTemplates:
              - template: /eng/pipelines/common/templates/runtimes/test-variables.yml

      #
      # 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
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(variables['isRollingBuild'], 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_x86
          - windows_arm64
          helixQueueGroup: pr
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          jobParameters:
            testGroup: innerloop
            liveLibrariesBuildConfig: Release
            unifiedArtifactsName: CoreCLR_ReleaseLibraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            unifiedBuildNameSuffix: CoreCLR_ReleaseLibraries
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(variables['isRollingBuild'], 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_x64
          helixQueueGroup: pr
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          jobParameters:
            testGroup: innerloop
            liveLibrariesBuildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
            unifiedArtifactsName: Libraries_CheckedCoreCLR_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(debugOnPrReleaseOnRolling)
            unifiedBuildNameSuffix: Libraries_CheckedCoreCLR
            unifiedBuildConfigOverride: ${{ variables.debugOnPrReleaseOnRolling }}
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/templates/runtimes/run-test-job.yml
          buildConfig: checked
          platforms:
          - osx_arm64
          helixQueueGroup: pr
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          jobParameters:
            testGroup: innerloop
            liveLibrariesBuildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
            unifiedArtifactsName: Libraries_CheckedCoreCLR_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(debugOnPrReleaseOnRolling)
            unifiedBuildNameSuffix: Libraries_CheckedCoreCLR
            unifiedBuildConfigOverride: ${{ variables.debugOnPrReleaseOnRolling }}
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr_AppleSilicon.containsChange'], true),
                eq(variables['isRollingBuild'], 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_x86
          helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
          jobParameters:
            isOfficialBuild: false
            testScope: innerloop
            liveRuntimeBuildConfig: release
            unifiedArtifactsName: CoreCLR_Libraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            helixArtifactsName: CoreCLR_Libraries_TestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            unifiedBuildNameSuffix: CoreCLR_Libraries
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(variables['isRollingBuild'], 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_x64
          - osx_x64
          - linux_x64
          - linux_musl_x64
          helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
          jobParameters:
            isOfficialBuild: false
            testScope: innerloop
            liveRuntimeBuildConfig: release
            unifiedArtifactsName: CoreCLR_Libraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(debugOnPrReleaseOnRolling)
            helixArtifactsName: CoreCLR_Libraries_TestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(debugOnPrReleaseOnRolling)
            unifiedBuildNameSuffix: CoreCLR_Libraries
            unifiedBuildConfigOverride: ${{ variables.debugOnPrReleaseOnRolling }}
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(variables['isRollingBuild'], true))
      # The next three jobs run checked coreclr + <either debug or release in PR> libraries tests.
      # The matrix looks like the following, where the right columns specify which configurations
      # the libraries tests are built in.
      # ________________________________________
      # | Platform         | PR      | Rolling |
      # | ---------------- | ------- | ------- |
      # | linux-arm64      | Debug   | Release |
      # | windows-x86      | Debug   | Release |
      # | linux-musl-x64   | Debug   | Release |
      # | OSX-x64          | Debug   | Release |
      # | linux-musl-arm   | Release | Release |
      # | linux-musl-arm64 | Release | Release |
      # | linux-x64        | Release | Release |
      # | windows-x64      | Release | Release |

      #
      # Debug (PR) / Release (rolling) 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: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
          - linux_arm64
          - windows_x86
          - linux_musl_x64
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          helixQueueGroup: libraries
          jobParameters:
            testScope: innerloop
            liveRuntimeBuildConfig: checked
            unifiedArtifactsName: Libraries_CheckedCoreCLR_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            helixArtifactsName: Libraries_CheckedCoreCLR_TestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            unifiedBuildNameSuffix: Libraries_CheckedCoreCLR
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Release 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: Release
          platforms:
          - linux_musl_arm
          - linux_musl_arm64
          - linux_x64
          - windows_x64
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          helixQueueGroup: libraries
          jobParameters:
            testScope: innerloop
            liveRuntimeBuildConfig: checked
            unifiedArtifactsName: CoreCLR_ReleaseLibraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_Checked
            helixArtifactsName: CoreCLR_ReleaseLibraries_TestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_Checked
            unifiedBuildNameSuffix: CoreCLR_ReleaseLibraries
            unifiedBuildConfigOverride: checked
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - 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
            unifiedArtifactsName: Libraries_CheckedCoreCLR_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            helixArtifactsName: Libraries_CheckedCoreCLR_TestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            unifiedBuildNameSuffix: Libraries_CheckedCoreCLR
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build and test Mono Interpreter with the libraries testss
      #
      - 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: ${{ variables.debugOnPrReleaseOnRolling }}
          runtimeFlavor: mono
          runtimeVariant: monointerpreter
          platforms:
            - linux_x64
            #- osx_x64
            #- windows_x64
          jobParameters:
            testGroup: innerloop
            nameSuffix: Mono_Interpreter_LibrariesTests
            buildArgs: -s mono+libs+libs.tests -rc Release -c $(_BuildConfig) /p:ArchiveTests=true
            timeoutInMinutes: 480
            # extra steps, run tests
            postBuildSteps:
              - template: /eng/pipelines/libraries/helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: Mono_Interpreter_$(_BuildConfig)
                  interpreter: true
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build and test Mono Minijit with the libraries testss
      #
      - 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: ${{ variables.debugOnPrReleaseOnRolling }}
          runtimeFlavor: mono
          platforms:
            - linux_arm64
            - linux_x64
            - osx_x64
            #- windows_x64
          jobParameters:
            testGroup: innerloop
            nameSuffix: Mono_MiniJIT_LibrariesTests
            buildArgs: -s mono+libs+libs.tests -rc Release -c $(_BuildConfig) /p:ArchiveTests=true
            timeoutInMinutes: 480
            # extra steps, run tests
            postBuildSteps:
              - template: /eng/pipelines/libraries/helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: Mono_Minijit_$(_BuildConfig)
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(variables['isRollingBuild'], true))

    - stage: SourceBuild
      displayName: Source Build Validation
      dependsOn: []
      condition: eq(variables['isRollingBuild'], true)
      jobs:
        #
        # Sourcebuild legs
        # We have 3 important legs for source-build:
        # - Centos.9 (ensures that known non-portable RID is working)
        # - Linux-x64 portable (used for dependency flow and downstream PR verification)
        # - Banana.24 - Non-existent RID to ensure we don't break RIDs we don't know about.
        #
        # Running all of these everywhere is wasteful. Run Banana.24 and CentOS.9 in rolling CI,
        # Run Linux-x64 in PR.
        - template: /eng/common/templates/jobs/source-build.yml
          parameters:
            platforms:
              - name: CentOS9
                baseOS: linux-x64
                targetRID: centos.9-x64
                portableBuild: false
                container: SourceBuild_centos_x64
              - name: NonexistentRID
                baseOS: linux-x64
                targetRID: banana.24-x64
                portableBuild: false
                container: SourceBuild_centos_x64