path: root/eng/pipelines/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:
    - '*'
    - docs/manpages/*
    exclude:
    - '**.md'
    - eng/Version.Details.xml
    - .devcontainer/*
    - .github/*
    - docs/*
    - LICENSE.TXT
    - PATENTS.TXT
    - THIRD-PARTY-NOTICES.TXT

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

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

jobs:

#
# Evaluate paths
#
- ${{ if eq(variables.dependOnEvaluatePaths, true) }}:
  - template: /eng/pipelines/common/evaluate-default-paths.yml

#
# 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_x86
    - Linux_x64
    - Linux_arm
    - Linux_arm64
    - Linux_musl_arm
    - Linux_musl_arm64
    - Linux_musl_x64
    - OSX_arm64
    - Tizen_armel
    - windows_x86
    - windows_x64
    - windows_arm
    - windows_arm64
    jobParameters:
      testGroup: innerloop
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_runtimetests.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/coreclr/templates/build-job.yml
    buildConfig: checked
    platforms:
    - Linux_x64
    container: debian-11-gcc12-amd64-20220511124845-b7a6185
    jobParameters:
      testGroup: innerloop
      compilerName: gcc
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(variables['isRollingBuild'], 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.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(variables['isRollingBuild'], 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_arm64
    - OSX_x64
    - Linux_x64
    - Linux_arm
    - Linux_arm64
    - Linux_musl_x64
    - Linux_musl_arm
    - Linux_musl_arm64
    - windows_x64
    - windows_x86
    - windows_arm
    - windows_arm64
    - FreeBSD_x64
    jobParameters:
      testGroup: innerloop

#
# Build CoreCLR Formatting Job
# Only when CoreCLR is changed, and only in the 'main' branch (no release branches;
# both Rolling and PR builds).
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/coreclr/templates/format-job.yml
    platforms:
    - Linux_x64
    - windows_x64
    jobParameters:
      condition: >-
        and(
          or(
            eq(variables['Build.SourceBranchName'], 'main'),
            eq(variables['System.PullRequest.TargetBranch'], 'main')),
          or(
            eq(dependencies.evaluate_paths.outputs['SetPathVars_coreclr_jit.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
    buildConfig: debug
    platforms:
    - Linux_x64
    - windows_x64
    jobParameters:
      testGroup: innerloop
      timeoutInMinutes: 120
      nameSuffix: NativeAOT
      buildArgs: -s clr.aot+libs -rc $(_BuildConfig) -lc Release
      extraStepsTemplate: /eng/pipelines/coreclr/nativeaot-post-build-steps.yml
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(variables['isFullMatrix'], 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
    buildConfig: checked
    platforms:
    - windows_x64
    jobParameters:
      testGroup: innerloop
      timeoutInMinutes: 120
      nameSuffix: NativeAOT
      buildArgs: -s clr.aot+libs -rc $(_BuildConfig) -lc Release
      extraStepsTemplate: /eng/pipelines/coreclr/nativeaot-post-build-steps.yml
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(variables['isFullMatrix'], 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
    buildConfig: release
    platforms:
    - Linux_x64
    - windows_x64
    - OSX_x64
    jobParameters:
      testGroup: innerloop
      timeoutInMinutes: 120
      nameSuffix: NativeAOT
      buildArgs: -s clr.aot+libs -rc $(_BuildConfig) -lc Release
      extraStepsTemplate: /eng/pipelines/coreclr/nativeaot-post-build-steps.yml
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(variables['isFullMatrix'], 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
    jobParameters:
      testGroup: innerloop
      isSingleFile: true
      nameSuffix: NativeAOT
      buildArgs: -s clr.aot+libs+libs.tests -c $(_BuildConfig) /p:TestNativeAot=true /p:RunSmokeTestsOnly=true /p:ArchiveTests=true
      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
      extraStepsTemplate: /eng/pipelines/libraries/helix.yml
      extraStepsParameters:
        creator: dotnet-bot
        testRunNamePrefixSuffix: NativeAOT_$(_BuildConfig)
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.evaluate_paths.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
      timeoutInMinutes: 120
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
          eq(variables['isRollingBuild'], true))

# Build Mono AOT offset headers once, for consumption elsewhere
# Only when mono changed
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/mono/templates/generate-offsets.yml
    buildConfig: release
    platforms:
    - Android_x64
    - Browser_wasm
    - tvOS_arm64
    - iOS_arm64
    - MacCatalyst_x64
    jobParameters:
      isOfficialBuild: ${{ variables.isOfficialBuild }}
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.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
    - iOSSimulator_x86
    - Linux_arm
    jobParameters:
      testGroup: innerloop
      nameSuffix: AllSubsets_Mono
      buildArgs: -s mono+libs+host+packs -c $(_BuildConfig)
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.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:
    - iOS_arm
    - Linux_musl_x64
    jobParameters:
      testGroup: innerloop
      nameSuffix: AllSubsets_Mono
      buildArgs: -s mono+libs+host+packs -c $(_BuildConfig)
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.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
    buildAndRunWasi: true
    alwaysRun: ${{ variables.isRollingBuild }}
    scenarios:
      - normal
      - WasmTestOnBrowser

# 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
    alwaysRun: ${{ variables.isRollingBuild }}

# AOT Library tests
- template: /eng/pipelines/common/templates/wasm-library-aot-tests.yml
  parameters:
    platforms:
      - Browser_wasm
    nameSuffix: _AOT
    runAOT: true
    runSmokeOnlyArg: $(_runSmokeTestsOnlyArg)
    alwaysRun: ${{ variables.isRollingBuild }}

- template: /eng/pipelines/common/templates/wasm-build-tests.yml
  parameters:
    platforms:
      - Browser_wasm
    alwaysRun: ${{ variables.isRollingBuild }}

- template: /eng/pipelines/common/templates/wasm-runtime-tests.yml
  parameters:
    platforms:
      - Browser_wasm
    alwaysRun: ${{ variables.isRollingBuild }}

# BUILD ONLY - Wasm Threading Legs
- template: /eng/pipelines/common/templates/wasm-build-only.yml
  parameters:
    platforms:
      - Browser_wasm
    nameSuffix: _Threading
    extraBuildArgs: /p:WasmEnableThreads=true
    alwaysRun: ${{ variables.isRollingBuild }}

- template: /eng/pipelines/common/templates/wasm-build-only.yml
  parameters:
    platforms:
      - Browser_wasm
    nameSuffix: _Threading_PerfTracing
    extraBuildArgs: /p:WasmEnablePerfTracing=true
    alwaysRun: ${{ variables.isRollingBuild }}

#
# 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: $[ dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
      - name: monoContainsChange
        value: $[ dependencies.evaluate_paths.outputs['SetPathVars_mono.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=true /p:BuildDarwinFrameworks=true
      timeoutInMinutes: 180
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
          eq(variables['isRollingBuild'], true))
      # extra steps, run tests
      extraStepsTemplate: /eng/pipelines/libraries/helix.yml
      extraStepsParameters:
        creator: dotnet-bot
        testRunNamePrefixSuffix: Mono_$(_BuildConfig)
        extraHelixArguments: /p:NeedsToBuildAppsOnHelix=true
        condition: >-
          or(
          eq(variables['librariesContainsChange'], true),
          eq(variables['monoContainsChange'], 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
    - ${{ if eq(variables['isRollingBuild'], true) }}:
      - MacCatalyst_arm64
    variables:
      # map dependencies variables to local variables
      - name: librariesContainsChange
        value: $[ dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
      - name: monoContainsChange
        value: $[ dependencies.evaluate_paths.outputs['SetPathVars_mono.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 /p:BuildDarwinFrameworks=true
      timeoutInMinutes: 180
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
          eq(variables['isRollingBuild'], 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['isRollingBuild'], 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+host+packs -c $(_BuildConfig)
                 /p:MonoEnableLLVM=true /p:MonoBundleLLVMOptimizer=false
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.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:
    - Linux_x64
    - Linux_arm64
    jobParameters:
      testGroup: innerloop
      nameSuffix: AllSubsets_Mono_LLVMJIT
      buildArgs: -s mono+libs+host+packs -c $(_BuildConfig)
                 /p:MonoEnableLLVM=true /p:MonoBundleLLVMOptimizer=false
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_installer.containsChange'], 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:MonoBundleLLVMOptimizer=true
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.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:MonoBundleLLVMOptimizer=true
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
          eq(variables['isRollingBuild'], 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
    - OSX_arm64
    - Linux_x64
    - Linux_arm64
    # - Linux_musl_arm64
    - windows_x64
    - windows_x86
    # - windows_arm
    # - windows_arm64
    jobParameters:
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.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/mono/templates/build-job.yml
    runtimeFlavor: mono
    buildConfig: release
    platforms:
    - Linux_x64
    # - Linux_arm64
    # - Linux_musl_arm64
    - Windows_x64
    # - windows_x86
    # - windows_arm
    # - windows_arm64
    jobParameters:
      runtimeVariant: crossaot
      dependsOn:
      - mono_android_offsets
      - mono_browser_offsets
      monoCrossAOTTargetOS:
      - Android
      - Browser
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
          eq(variables['isRollingBuild'], true))

- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/mono/templates/build-job.yml
    runtimeFlavor: mono
    buildConfig: release
    platforms:
    - OSX_x64
    jobParameters:
      runtimeVariant: crossaot
      dependsOn:
      - mono_android_offsets
      - mono_browser_offsets
      - mono_tvos_offsets
      - mono_ios_offsets
      - mono_maccatalyst_offsets
      monoCrossAOTTargetOS:
      - Android
      - Browser
      - tvOS
      - iOS
      - MacCatalyst
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
          eq(variables['isRollingBuild'], 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_x64
    - windows_x86
    # - windows_arm
    # - windows_arm64
    jobParameters:
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(variables['isRollingBuild'], 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.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(variables['isRollingBuild'], 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
    - Linux_arm64
    jobParameters:
      runtimeVariant: llvmaot
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(variables['isRollingBuild'], 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_arm
    - Linux_musl_arm64
    - windows_arm
    - windows_arm64
    - windows_x86

- 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_arm64
    - OSX_x64
    - windows_x64
    - FreeBSD_x64
    jobParameters:
      testScope: innerloop

#
# Libraries debug build that only runs when coreclr is changed
# Only do this on PR builds since we use the Release builds for these test runs in CI
# and those are already built above
#
- ${{ if eq(variables['isRollingBuild'], false) }}:
  - template: /eng/pipelines/common/platform-matrix.yml
    parameters:
      jobTemplate: /eng/pipelines/libraries/build-job.yml
      buildConfig: Debug
      platforms:
      - windows_x86
      jobParameters:
        condition: >-
          eq(dependencies.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true)

#
# Libraries release build that only runs when coreclr is changed in PRs
# We need these for checked coreclr + release libraries tests runs.
#
- ${{ if eq(variables['isRollingBuild'], false) }}:
  - template: /eng/pipelines/common/platform-matrix.yml
    parameters:
      jobTemplate: /eng/pipelines/libraries/build-job.yml
      buildConfig: Release
      platforms:
      - Linux_x64
      - windows_x64
      jobParameters:
        condition: >-
          eq(dependencies.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true)

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

- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/libraries/build-job.yml
    buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
    platforms:
    - windows_x64
    jobParameters:
      framework: allConfigurations
      runTests: true
      useHelix: false
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.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/installer/installer-matrix.yml
  parameters:
    buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
    platforms:
      - Linux_musl_arm
      - Linux_musl_arm64
      - windows_x86
      - windows_arm
      - windows_arm64
      - Linux_arm
    jobParameters:
      liveRuntimeBuildConfig: release
      liveLibrariesBuildConfig: Release

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

#
# 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(dependencies.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
          eq(dependencies.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
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
          eq(dependencies.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 }}
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
          eq(dependencies.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 }}
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_coreclr_AppleSilicon.containsChange'], true),
          eq(variables['isRollingBuild'], 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
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(variables['isRollingBuild'], true))

#
# Mono CoreCLR runtime Test executions using live libraries in jit mode
# 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
    - windows_x64
    helixQueueGroup: pr
    helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
    jobParameters:
      testGroup: innerloop
      liveLibrariesBuildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
      liveRuntimeBuildConfig: release
      runtimeVariant: minijit
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(variables['isRollingBuild'], true))

#
# 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/templates/runtimes/run-test-job.yml
    buildConfig: release
    runtimeFlavor: mono
    platforms:
    - OSX_x64
    helixQueueGroup: pr
    helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
    jobParameters:
      testGroup: innerloop
      liveLibrariesBuildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
      liveRuntimeBuildConfig: release
      runtimeVariant: monointerpreter
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(variables['isRollingBuild'], 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
    # Disabled pending outcome of https://github.com/dotnet/runtime/issues/60234 investigation
    #- Linux_arm64
    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.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(variables['isRollingBuild'], true))

#
# Mono CoreCLR runtime Test executions using live libraries and LLVM Full 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
    - Linux_arm64
    helixQueueGroup: pr
    helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
    jobParameters:
      testGroup: innerloop
      liveLibrariesBuildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
      liveRuntimeBuildConfig: release
      runtimeVariant: llvmfullaot
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(variables['isRollingBuild'], 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_x64
    - OSX_x64
    - Linux_arm64
    - Linux_x64
    helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
    jobParameters:
      isOfficialBuild: false
      runtimeDisplayName: mono
      testScope: innerloop
      liveRuntimeBuildConfig: release
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(variables['isRollingBuild'], 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_x64
    #- OSX_x64
    - Linux_x64
    helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
    jobParameters:
      isOfficialBuild: false
      interpreter: true
      runtimeDisplayName: mono_interpreter
      testScope: innerloop
      liveRuntimeBuildConfig: release
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.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
      condition: >-
        or(
          eq(dependencies.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
      condition: >-
        or(
          eq(dependencies.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
      condition: >-
        or(
          eq(dependencies.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
      condition: >-
        or(
          eq(dependencies.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
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
          eq(variables['isRollingBuild'], true))