# This contains only jobs that are not runnable by a platform specific
# pipeline, like runtime-wasm
# These are run as part of runtime-extra-platforms by default.

parameters:
  isExtraPlatformsBuild: ''

jobs:

#
# 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:
    - Linux_x64
    - Linux_arm
    - Linux_arm64
    - Linux_musl_x64
    - OSX_x64
    - windows_x64
    - windows_x86
    - windows_arm64
    jobParameters:
      testGroup: innerloop

#
# Build libraries using live CoreLib
#
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/libraries/build-job.yml
    buildConfig: Release
    platforms:
    - Linux_x64
    - Linux_arm
    - Linux_arm64
    - Linux_musl_x64
    - OSX_x64
    - windows_x64
    - windows_x86
    - windows_arm64

#
# 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:
    - Linux_x64
    - Linux_arm
    - Linux_arm64
    - Linux_musl_x64
    - OSX_x64
    - windows_x64
    - windows_x86
    - windows_arm64
    helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
    jobParameters:
      isOfficialBuild: false
      isExtraPlatforms: ${{ parameters.isExtraPlatformsBuild }}
      testScope: innerloop
      liveRuntimeBuildConfig: release
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
          eq(variables['isRollingBuild'], true))

#
# CoreCLR NativeAOT release build and additional libraries tests that are known to be passing
# 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_x64
    - windows_arm64
    - Linux_x64
    - Linux_arm64
    - Linux_musl_x64
    jobParameters:
      testGroup: innerloop
      isSingleFile: true
      nameSuffix: NativeAOT_Libs
      buildArgs: -s clr.aot+libs+libs.tests -c $(_BuildConfig) /p:TestNativeAot=true /p:ArchiveTests=true
      timeoutInMinutes: 240
      # 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['isRollingBuild'], true))

# Run net48 tests on win-x64
- template: /eng/pipelines/common/platform-matrix.yml
  parameters:
    jobTemplate: /eng/pipelines/libraries/build-job.yml
    buildConfig: Release
    platforms:
    - windows_x64
    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))

#### MONO LEGS

#
# 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:
    - Windows_x64
    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:
      testScope: innerloop
      nameSuffix: AllSubsets_Mono
      buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true
      timeoutInMinutes: 120
      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))

#
# iOS/tvOS 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:
    - iOSSimulator_x64
    - tvOSSimulator_x64
    # don't run tests on arm64 PRs until we can get significantly more devices
    - ${{ if eq(variables['isRollingBuild'], true) }}:
      - iOSSimulator_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 $(_runSmokeTestsOnlyArg) /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
        interpreter: true
        testRunNamePrefixSuffix: Mono_$(_BuildConfig)
        condition: >-
          or(
          eq(variables['librariesContainsChange'], true),
          eq(variables['monoContainsChange'], 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: $[ dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
      - name: monoContainsChange
        value: $[ dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'] ]
    jobParameters:
      testGroup: innerloop
      nameSuffix: AllSubsets_Mono
      isExtraPlatforms: ${{ parameters.isExtraPlatformsBuild }}
      buildArgs: -s mono+libs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true /p:DevTeamProvisioning=- /p:RunAOTCompilation=true $(_runSmokeTestsOnlyArg) /p:BuildTestsOnHelix=true /p:EnableAdditionalTimezoneChecks=true /p:UsePortableRuntimePack=true /p:BuildDarwinFrameworks=true /p:IsManualOrRollingBuild=true
      timeoutInMinutes: 180
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.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
      - 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: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))
#
# MacCatalyst interp - requires AOT Compilation and Interp flags
# Build the whole product using Mono and run libraries tests
# The test app is built with the App Sandbox entitlement
#
- 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: $[ dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
      - name: monoContainsChange
        value: $[ dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'] ]
    jobParameters:
      testGroup: innerloop
      nameSuffix: AllSubsets_Mono_AppSandbox
      buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true $(_runSmokeTestsOnlyArg) /p:DevTeamProvisioning=adhoc /p:RunAOTCompilation=true /p:MonoForceInterpreter=true /p:BuildDarwinFrameworks=true /p:EnableAppSandbox=true
      timeoutInMinutes: 180
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(variables['isRollingBuild'], true))
      # extra steps, run tests
      extraStepsTemplate: /eng/pipelines/libraries/helix.yml
      extraStepsParameters:
        creator: dotnet-bot
        interpreter: true
        testRunNamePrefixSuffix: Mono_$(_BuildConfig)
        condition: >-
          or(
            eq(variables['librariesContainsChange'], true),
            eq(variables['monoContainsChange'], true),
            eq(variables['isRollingBuild'], true))

#
# Android emulators
# 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_x86
    - Android_x64
    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 $(_runSmokeTestsOnlyArg)
      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))

#
# 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: $[ 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 $(_runSmokeTestsOnlyArg) /p:EnableAdditionalTimezoneChecks=true
      timeoutInMinutes: 180
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.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 the whole product using Mono for Android Linux with Bionic libc
#
- 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:
      - Linux_bionic_arm64
      - Linux_bionic_x64
    variables:
      - ${{ if and(eq(variables['System.TeamProject'], 'public'), eq(variables['Build.Reason'], 'PullRequest')) }}:
        - name: _HelixSource
          value: pr/dotnet/runtime/$(Build.SourceBranch)
      - ${{ if and(eq(variables['System.TeamProject'], 'public'), ne(variables['Build.Reason'], 'PullRequest')) }}:
        - name: _HelixSource
          value: ci/dotnet/runtime/$(Build.SourceBranch)
      - name: timeoutPerTestInMinutes
        value: 60
      - name: timeoutPerTestCollectionInMinutes
        value: 180
    jobParameters:
      testGroup: innerloop
      targetRid: Linux-bionic-x64
      nameSuffix: AllSubsets_Mono
      buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true
      timeoutInMinutes: 240
      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)_LinuxBionic

#
# Build the whole product using Mono and run runtime tests
# 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:
    - 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))

#
# 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))

#
# Build the whole product using Mono for Android and run runtime tests with Android emulator
#
- 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:
    - Android_x64
    variables:
      - ${{ if and(eq(variables['System.TeamProject'], 'public'), eq(variables['Build.Reason'], 'PullRequest')) }}:
        - name: _HelixSource
          value: pr/dotnet/runtime/$(Build.SourceBranch)
      - ${{ if and(eq(variables['System.TeamProject'], 'public'), ne(variables['Build.Reason'], 'PullRequest')) }}:
        - name: _HelixSource
          value: ci/dotnet/runtime/$(Build.SourceBranch)
      - name: timeoutPerTestInMinutes
        value: 60
      - name: timeoutPerTestCollectionInMinutes
        value: 180
    jobParameters:
      testGroup: innerloop
      nameSuffix: AllSubsets_Mono_RuntimeTests
      buildArgs: -s mono+libs -c $(_BuildConfig)
      timeoutInMinutes: 240
      condition: >-
        or(
            eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
            eq(dependencies.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
            eq(variables['isRollingBuild'], true))
      # extra steps, run tests
      extraStepsTemplate: /eng/pipelines/common/templates/runtimes/android-runtime-and-send-to-helix.yml
      extraStepsParameters:
        creator: dotnet-bot
        testRunNamePrefixSuffix: Mono_$(_BuildConfig)

#
# Build the whole product using Mono for Android and run runtime tests with interpreter
#
- 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:
      - Android_x64
    variables:
      - ${{ if and(eq(variables['System.TeamProject'], 'public'), eq(variables['Build.Reason'], 'PullRequest')) }}:
        - name: _HelixSource
          value: pr/dotnet/runtime/$(Build.SourceBranch)
      - ${{ if and(eq(variables['System.TeamProject'], 'public'), ne(variables['Build.Reason'], 'PullRequest')) }}:
        - name: _HelixSource
          value: ci/dotnet/runtime/$(Build.SourceBranch)
      - name: timeoutPerTestInMinutes
        value: 60
      - name: timeoutPerTestCollectionInMinutes
        value: 180
    jobParameters:
      testGroup: innerloop
      nameSuffix: AllSubsets_Mono_RuntimeTests_Interp
      buildArgs: -s mono+libs -c $(_BuildConfig)
      timeoutInMinutes: 240
      runtimeVariant: monointerpreter
      condition: >-
        or(
          eq(dependencies.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
          eq(dependencies.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
          eq(variables['isRollingBuild'], true))
      # extra steps, run tests
      extraStepsTemplate: /eng/pipelines/common/templates/runtimes/android-runtime-and-send-to-helix.yml
      extraStepsParameters:
        creator: dotnet-bot
        testRunNamePrefixSuffix: Mono_$(_BuildConfig)

#
# 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:
    - Linux_arm64
    helixQueueGroup: pr
    helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
    jobParameters:
      testGroup: innerloop
      liveLibrariesBuildConfig: Release
      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:
    - Linux_arm64
    helixQueueGroup: pr
    helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
    jobParameters:
      testGroup: innerloop
      liveLibrariesBuildConfig: Release
      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))