Stop cross building other Linux distros

We should now be able to build natively on all Linux distros. Let's cut
out building some components on Windows and others on Linux and using
run-test.sh in favor of just doing everything on the target machine.

We also move to using CLR from packages instead of a live CLR.

I have also removed the outerloop runs we were doing with a checked
CoreCLR, it turns out that CoreCLR had similar runs and the failures are
more actionable to them.

Fixes #8860

1 files changed, 26 insertions, 393 deletions

diff --git a/netci.groovy b/netci.groovy
index 38fc55e9cd..32efd61775 100644
--- a/netci.groovy
+++ b/netci.groovy
@@ -22,14 +22,15 @@ def osGroupMap = ['Ubuntu14.04':'Linux',
                   'CentOS7.1': 'Linux',
                   'OpenSUSE13.2': 'Linux',
                   'RHEL7.2': 'Linux']
+
 // Map of os -> nuget runtime
 def targetNugetRuntimeMap = ['OSX' : 'osx.10.10-x64',
                              'Ubuntu14.04' : 'ubuntu.14.04-x64',
-                             'Ubuntu16.04' : 'ubuntu.14.04-x64',
-                             'Fedora23' : 'ubuntu.14.04-x64',
+                             'Ubuntu16.04' : 'ubuntu.16.04-x64',
+                             'Fedora23' : 'fedora.23-x64',
                              'Debian8.4' : 'debian.8-x64',
                              'CentOS7.1' : 'centos.7-x64',
-                             'OpenSUSE13.2' : 'ubuntu.14.04-x64',
+                             'OpenSUSE13.2' : 'opensuse.13.2-x64',
                              'RHEL7.2': 'rhel.7-x64']
 
 def osShortName = ['Windows 10': 'win10',
@@ -40,6 +41,7 @@ def osShortName = ['Windows 10': 'win10',
                    'Windows Nano 2016' : 'winnano16',
                    'Ubuntu16.04' : 'ubuntu16.04',
                    'CentOS7.1' : 'centos7.1',
+                   'Debian8.4' : 'debian8.4',
                    'OpenSUSE13.2' : 'opensuse13.2',
                    'Fedora23' : 'fedora23',
                    'RHEL7.2' : 'rhel7.2']
@@ -201,124 +203,10 @@ def osShortName = ['Windows 10': 'win10',
 }
 
 // **************************
-// Define outerloop testing for linux OSes that can't build.  Run locally on each machine.
-// **************************
-def outerloopLinuxOSes = ['Ubuntu16.04', 'CentOS7.1', 'OpenSUSE13.2', 'RHEL7.2', 'Fedora23', 'Debian8.4']
-[true, false].each { isPR ->
-    ['Debug', 'Release'].each { configurationGroup ->
-        outerloopLinuxOSes.each { os ->
-            def osGroup = osGroupMap[os]
-
-            //
-            // First define the nativecomp build
-            //
-            
-            def newNativeCompBuildJobName = "outerloop_nativecomp_${os.toLowerCase()}_${configurationGroup.toLowerCase()}"
-            
-            def newNativeCompJob = job(Utilities.getFullJobName(project, newNativeCompBuildJobName, isPR)) {
-                steps {
-                    shell("./build.sh native x64 ${configurationGroup.toLowerCase()}")
-                }
-            }
-            
-            // Set the affinity.  Use the 'latest or auto' version to pick up
-            // new auto images.
-            Utilities.setMachineAffinity(newNativeCompJob, os, 'outer-latest-or-auto')
-            // Set up standard options.
-            Utilities.standardJobSetup(newNativeCompJob, project, isPR, "*/${branch}")
-            // Add archival for the built data.
-            Utilities.addArchival(newNativeCompJob, "bin/**")
-            
-            //
-            // First we set up a build job that builds the corefx repo on Windows
-            //
-            
-            def newBuildJobName = "outerloop_${os.toLowerCase()}_${configurationGroup.toLowerCase()}_bld"
-
-            def newBuildJob = job(Utilities.getFullJobName(project, newBuildJobName, isPR)) {
-                steps {
-                    batchFile("call \"C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\vcvarsall.bat\" x86 && build.cmd /p:ConfigurationGroup=${configurationGroup} /p:TargetOS=${osGroup} /p:OSGroup=${osGroup} /p:SkipTests=true /p:TestNugetRuntimeId=${targetNugetRuntimeMap[os]} /p:WithoutCategories=IgnoreForCI /p:TestWithoutNativeImages=true /p:Outerloop=true")
-                    // Package up the results.
-                    batchFile("C:\\Packer\\Packer.exe .\\bin\\build.pack . bin packages")
-                }
-            }
-
-            // Set the affinity.  All of these run on Windows currently.
-            Utilities.setMachineAffinity(newBuildJob, 'Windows_NT', 'latest-or-auto')
-            // Set up standard options.
-            Utilities.standardJobSetup(newBuildJob, project, isPR, "*/${branch}")
-            // Archive the results
-            Utilities.addArchival(newBuildJob, "bin/build.pack,msbuild.log")
-
-            //
-            // Then we set up a job that runs the test on the target OS
-            //
-            
-            def fullNativeCompBuildJobName = projectFolder + '/' + newNativeCompJob.name
-            def fullCoreFXBuildJobName = projectFolder + '/' + newBuildJob.name
-            
-            def newTestJobName = "outerloop_${os.toLowerCase()}_${configurationGroup.toLowerCase()}_tst"
-            
-            def newTestJob = job(Utilities.getFullJobName(project, newTestJobName, isPR)) { }
-
-            addCopyCoreClrAndRunTestSteps(newTestJob, branch, os, osGroup, fullNativeCompBuildJobName, fullCoreFXBuildJobName, configurationGroup, 'Release', true, false)
-            
-            // Set the affinity.  All of these run on the target
-            Utilities.setMachineAffinity(newTestJob, os, 'outer-latest-or-auto')
-            // Set up standard options.
-            Utilities.standardJobSetup(newTestJob, project, isPR, "*/${branch}")
-            // Add the unit test results
-            Utilities.addXUnitDotNETResults(newTestJob, '**/testResults.xml')
-            
-            //
-            // Then we set up a flow job that runs the build and the nativecomp build in parallel and then executes.
-            // the test job
-            //
-            
-            def fullCoreFXTestJobName = projectFolder + '/' + newTestJob.name
-            def flowJobName = "outerloop_${os.toLowerCase()}_${configurationGroup.toLowerCase()}"
-            def newFlowJob = buildFlowJob(Utilities.getFullJobName(project, flowJobName, isPR)) {
-                buildFlow("""
-                    parallel (
-                        { nativeCompBuild = build(params, '${fullNativeCompBuildJobName}') },
-                        { coreFXBuild = build(params, '${fullCoreFXBuildJobName}') }
-                    )
-                    
-                    // Then run the test job
-                    build(params + 
-                        [COREFX_BUILD: coreFXBuild.build.number,
-                         COREFX_NATIVECOMP_BUILD : nativeCompBuild.build.number], '${fullCoreFXTestJobName}')
-                """)
-                
-                // Needs a workspace
-                configure {
-                    def buildNeedsWorkspace = it / 'buildNeedsWorkspace'
-                    buildNeedsWorkspace.setValue('true')
-                }
-            }
-            
-            // Set the affinity.  All of these run on the target
-            Utilities.setMachineAffinity(newFlowJob, os, 'outer-latest-or-auto')
-            // Set up standard options.
-            Utilities.standardJobSetup(newFlowJob, project, isPR, "*/${branch}")
-            // Set up triggers
-            if (isPR) {
-                // Set PR trigger.
-                Utilities.addGithubPRTriggerForBranch(newFlowJob, branch, "OuterLoop ${os} ${configurationGroup}", "(?i).*test\\W+outerloop\\W+${os}\\W+${configurationGroup}.*")
-            }
-            else {
-                // Set a push trigger
-                Utilities.addPeriodicTrigger(newFlowJob, '@daily')
-            }
-        }
-    }
-}
-
-// **************************
 // Define outerloop testing for OSes that can build and run.  Run locally on each machine.
 // **************************
 [true, false].each { isPR ->
-    ['Windows 10', 'Windows 7', 'Windows_NT', 'Ubuntu14.04', 'OSX'].each { os ->
+    ['Windows 10', 'Windows 7', 'Windows_NT', 'Ubuntu14.04', 'Ubuntu16.04', 'CentOS7.1', 'OpenSUSE13.2', 'RHEL7.2', 'Fedora23', 'Debian8.4', 'OSX'].each { os ->
         ['Debug', 'Release'].each { configurationGroup ->
 
             def newJobName = "outerloop_${osShortName[os]}_${configurationGroup.toLowerCase()}"
@@ -332,20 +220,19 @@ def outerloopLinuxOSes = ['Ubuntu16.04', 'CentOS7.1', 'OpenSUSE13.2', 'RHEL7.2',
                         shell("HOME=\$WORKSPACE/tempHome ./build.sh ${configurationGroup.toLowerCase()} /p:ConfigurationGroup=${configurationGroup} /p:Outerloop=true /p:TestWithLocalLibraries=true /p:WithoutCategories=IgnoreForCI")
                     }
                     else {
-                        shell("sudo HOME=\$WORKSPACE/tempHome ./build.sh ${configurationGroup.toLowerCase()} /p:ConfigurationGroup=${configurationGroup} /p:Outerloop=true /p:TestWithLocalLibraries=true /p:WithoutCategories=IgnoreForCI")
+                        shell("sudo HOME=\$WORKSPACE/tempHome ./build.sh ${configurationGroup.toLowerCase()} /p:TestNugetRuntimeId=${targetNugetRuntimeMap[os]} /p:ConfigurationGroup=${configurationGroup} /p:Outerloop=true /p:TestWithLocalLibraries=true /p:WithoutCategories=IgnoreForCI")
                     }
                 }
             }
 
             // Set the affinity.  OS name matches the machine affinity.
-            if (os == 'Ubuntu14.04') {
-                Utilities.setMachineAffinity(newJob, os, "outer-latest-or-auto")    
-            }
-            else if (os == 'Windows_NT') {
-                 Utilities.setMachineAffinity(newJob, os, "latest-or-auto-elevated")
+            if (os == 'Windows_NT') {
+                Utilities.setMachineAffinity(newJob, os, "latest-or-auto-elevated")
             }
-            else {
-                Utilities.setMachineAffinity(newJob, os, 'latest-or-auto')
+            else if (osGroupMap[os] == 'Linux') {
+                Utilities.setMachineAffinity(newJob, os, 'outer-latest-or-auto')
+            } else {
+                Utilities.setMachineAffinity(newJob, os, 'latest-or-auto');
             }
 
             // Set up standard options.
@@ -353,11 +240,6 @@ def outerloopLinuxOSes = ['Ubuntu16.04', 'CentOS7.1', 'OpenSUSE13.2', 'RHEL7.2',
             // Add the unit test results
             Utilities.addXUnitDotNETResults(newJob, 'bin/tests/**/testResults.xml')
 
-            // Unix runs take more than 2 hours to run, so we set the timeout to be longer.
-            if (os == 'Ubuntu14.04' || os == 'OSX') {
-                Utilities.setJobTimeout(newJob, 240)
-            }
-
             // Set up appropriate triggers.  PR on demand, otherwise nightly
             if (isPR) {
                 // Set PR trigger.
@@ -401,201 +283,13 @@ def outerloopLinuxOSes = ['Ubuntu16.04', 'CentOS7.1', 'OpenSUSE13.2', 'RHEL7.2',
     }
 }
 
-// adds steps to a job to download coreclr artifacts and corefx artifacts and invoke run-test.sh.
-def static addCopyCoreClrAndRunTestSteps(def job, def coreclrBranch, String os, String osGroup, String fullNativeCompBuildJobName, String fullCoreFXBuildJobName, String configurationGroup, String coreClrConfigurationGroup, boolean isOuterLoop, boolean useServerGC) {
-    // Grab the folder name for the coreclr branch
-    def coreclrFolder = Utilities.getFolderName(coreclrBranch)
-    job.with {
-        steps {
-            // CoreCLR
-            copyArtifacts("dotnet_coreclr/${coreclrFolder}/${coreClrConfigurationGroup.toLowerCase()}_${os.toLowerCase()}") {
-                excludePatterns('**/testResults.xml', '**/*.ni.dll')
-                buildSelector {
-                    latestSuccessful(true)
-                }
-            }
-
-            // MSCorlib
-            copyArtifacts("dotnet_coreclr/${coreclrFolder}/${coreClrConfigurationGroup.toLowerCase()}_windows_nt") {
-                includePatterns("bin/Product/${osGroup}*/**")
-                excludePatterns('**/testResults.xml', '**/*.ni.dll')
-                buildSelector {
-                    latestSuccessful(true)
-                }
-            }
-
-            // Native components
-            copyArtifacts(fullNativeCompBuildJobName) {
-                includePatterns("bin/**")
-                buildSelector {
-                    buildNumber('\${COREFX_NATIVECOMP_BUILD}')
-                }
-            }
-
-            // The tests/corefx components
-            copyArtifacts(fullCoreFXBuildJobName) {
-                includePatterns('bin/build.pack')
-                buildSelector {
-                    buildNumber('\${COREFX_BUILD}')
-                }
-            }
-
-            // Unpack the build data
-            shell("unpacker ./bin/build.pack .")
-            // Export the LTTNG environment variable and then run the tests
-            shell("""export LTTNG_HOME=/home/dotnet-bot
-            ${isOuterLoop ? 'sudo' : '' } ./run-test.sh \\
-                --configurationGroup ${configurationGroup} \\
-                --os ${osGroup} \\
-                --corefx-tests \${WORKSPACE}/bin/tests/${osGroup}.AnyCPU.${configurationGroup}/ \\
-                --coreclr-bins \${WORKSPACE}/bin/Product/${osGroup}.x64.${coreClrConfigurationGroup}/ \\
-                --mscorlib-bins \${WORKSPACE}/bin/Product/${osGroup}.x64.${coreClrConfigurationGroup}/ \\
-                --IgnoreForCI \\
-                ${useServerGC ? '--serverGc' : ''} ${isOuterLoop ? '--outerloop' : ''}
-            ${isOuterLoop ? 'sudo find . -name \"testResults.xml\" -exec chmod 777 {} \\;' : ''}
-            """)
-        }
-
-        // Add parameters for the input jobs
-        parameters {
-            stringParam('COREFX_BUILD', '', 'Build number to copy CoreFX test binaries from')
-            stringParam('COREFX_NATIVECOMP_BUILD', '', 'Build number to copy CoreFX native components from')
-        }
-    }
-}
-
-// Here are the OS's that needs separate builds and tests.
-// We create a build for the native compilation, a build for the build of corefx itself (on Windows)
-// and then a build for the test of corefx on the target platform.  Then we link them with a build
-// flow job.
-
-def innerLoopNonWindowsOSs = ['Ubuntu16.04', 'Debian8.4', 'CentOS7.1', 'OpenSUSE13.2', 'RHEL7.2', 'Fedora23']
-[true, false].each { isPR ->
-    ['Debug', 'Release'].each { configurationGroup ->
-        innerLoopNonWindowsOSs.each { os ->
-            def osGroup = osGroupMap[os]
-
-            //
-            // First define the nativecomp build
-            //
-            
-            def newNativeCompBuildJobName = "nativecomp_${os.toLowerCase()}_${configurationGroup.toLowerCase()}"
-            
-            def newNativeCompJob = job(Utilities.getFullJobName(project, newNativeCompBuildJobName, isPR)) {
-                steps {
-                    shell("./build.sh native x64 ${configurationGroup.toLowerCase()}")
-                }
-            }
-            
-            // Set the affinity.  Use the 'latest or auto' version to pick up
-            // new auto images.
-            Utilities.setMachineAffinity(newNativeCompJob, os, 'latest-or-auto')
-            // Set up standard options.
-            Utilities.standardJobSetup(newNativeCompJob, project, isPR, "*/${branch}")
-            // Add archival for the built data.
-            Utilities.addArchival(newNativeCompJob, "bin/**")
-            
-            //
-            // First we set up a build job that builds the corefx repo on Windows
-            //
-            
-            def newBuildJobName = "${os.toLowerCase()}_${configurationGroup.toLowerCase()}_bld"
-
-            def newBuildJob = job(Utilities.getFullJobName(project, newBuildJobName, isPR)) {
-                steps {
-                    batchFile("call \"C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\vcvarsall.bat\" x86 && build.cmd /p:ConfigurationGroup=${configurationGroup} /p:TargetOS=${osGroup} /p:OSGroup=${osGroup} /p:SkipTests=true /p:TestNugetRuntimeId=${targetNugetRuntimeMap[os]} /p:WithoutCategories=IgnoreForCI /p:TestWithoutNativeImages=true")
-                    // Package up the results.
-                    batchFile("C:\\Packer\\Packer.exe .\\bin\\build.pack . bin packages")
-                }
-            }
-
-            // Set the affinity.  All of these run on Windows currently.
-            Utilities.setMachineAffinity(newBuildJob, 'Windows_NT', 'latest-or-auto')
-            // Set up standard options.
-            Utilities.standardJobSetup(newBuildJob, project, isPR, "*/${branch}")
-            // Archive the results
-            Utilities.addArchival(newBuildJob, "bin/build.pack,msbuild.log")
-
-            //
-            // Then we set up a job that runs the test on the target OS
-            //
-            
-            def fullNativeCompBuildJobName = projectFolder + '/' + newNativeCompJob.name
-            def fullCoreFXBuildJobName = projectFolder + '/' + newBuildJob.name
-            
-            def newTestJobName = "${os.toLowerCase()}_${configurationGroup.toLowerCase()}_tst"
-            
-            def newTestJob = job(Utilities.getFullJobName(project, newTestJobName, isPR)) { }
-
-            addCopyCoreClrAndRunTestSteps(newTestJob, branch, os, osGroup, fullNativeCompBuildJobName, fullCoreFXBuildJobName, configurationGroup, 'Release', false, false)
-            
-            // Set the affinity.  All of these run on the target
-            Utilities.setMachineAffinity(newTestJob, os, 'latest-or-auto')
-            // Set up standard options.
-            Utilities.standardJobSetup(newTestJob, project, isPR, "*/${branch}")
-            // Add the unit test results
-            Utilities.addXUnitDotNETResults(newTestJob, '**/testResults.xml')
-            
-            //
-            // Then we set up a flow job that runs the build and the nativecomp build in parallel and then executes.
-            // the test job
-            //
-            
-            def fullCoreFXTestJobName = projectFolder + '/' + newTestJob.name
-            def flowJobName = "${os.toLowerCase()}_${configurationGroup.toLowerCase()}"
-            def newFlowJob = buildFlowJob(Utilities.getFullJobName(project, flowJobName, isPR)) {
-                buildFlow("""
-                    parallel (
-                        { nativeCompBuild = build(params, '${fullNativeCompBuildJobName}') },
-                        { coreFXBuild = build(params, '${fullCoreFXBuildJobName}') }
-                    )
-                    
-                    // Then run the test job
-                    build(params + 
-                        [COREFX_BUILD: coreFXBuild.build.number,
-                         COREFX_NATIVECOMP_BUILD : nativeCompBuild.build.number], '${fullCoreFXTestJobName}')
-                """)
-                
-                // Needs a workspace
-                configure {
-                    def buildNeedsWorkspace = it / 'buildNeedsWorkspace'
-                    buildNeedsWorkspace.setValue('true')
-                }
-            }
-            
-            // Set the affinity.  All of these run on the target
-            Utilities.setMachineAffinity(newFlowJob, os, 'latest-or-auto')
-            // Set up standard options.
-            Utilities.standardJobSetup(newFlowJob, project, isPR, "*/${branch}")
-            // Set up triggers
-            if (isPR) {
-                // Set PR trigger.
-                // Set of OS's that work currently. 
-                if (os in ['OpenSUSE13.2', 'CentOS7.1']) {
-                    // TODO #6070: Temporarily disabled due to failing globalization tests on OpenSUSE.
-                    if (os != 'OpenSUSE13.2') {
-                        Utilities.addGithubPRTriggerForBranch(newFlowJob, branch, "Innerloop ${os} ${configurationGroup} Build and Test")
-                    }
-                }
-                else {
-                    Utilities.addGithubPRTriggerForBranch(newFlowJob, branch, "Innerloop ${os} ${configurationGroup} Build and Test", "(?i).*test\\W+${os}.*")
-                }
-            }
-            else {
-                // Set a push trigger
-                Utilities.addGithubPushTrigger(newFlowJob)
-            }
-        }
-    }
-}
-
-// Generate the build and test versions for Windows_NT, Ubuntu14.04 and OSX.  When full build/run is supported on a platform, those platforms
-// could be removed from above and then added in below.
-def supportedFullCyclePlatforms = ['Windows_NT', 'Ubuntu14.04', 'OSX']
-
+// **************************
+// Define innerloop testing.  These jobs run on every merge and a subset of them run on every PR, the ones
+// that don't run per PR can be requested via a magic phrase.
+// **************************
 [true, false].each { isPR ->
     ['Debug', 'Release'].each { configurationGroup ->
-        supportedFullCyclePlatforms.each { os ->
+        ['Windows_NT', 'Ubuntu14.04', 'Ubuntu16.04', 'Debian8.4', 'CentOS7.1', 'OpenSUSE13.2', 'RHEL7.2', 'OSX'].each { os ->
             def osGroup = osGroupMap[os]
             def newJobName = "${os.toLowerCase()}_${configurationGroup.toLowerCase()}"
 
@@ -609,7 +303,7 @@ def supportedFullCyclePlatforms = ['Windows_NT', 'Ubuntu14.04', 'OSX']
                     else {
                         // Use Server GC for Ubuntu/OSX Debug PR build & test
                         def useServerGC = (configurationGroup == 'Release' && isPR) ? 'useServerGC' : ''
-                        shell("HOME=\$WORKSPACE/tempHome ./build.sh ${useServerGC} ${configurationGroup.toLowerCase()} /p:ConfigurationGroup=${configurationGroup} /p:TestWithLocalLibraries=true /p:WithoutCategories=IgnoreForCI")
+                        shell("HOME=\$WORKSPACE/tempHome ./build.sh ${useServerGC} ${configurationGroup.toLowerCase()} /p:TestNugetRuntimeId=${targetNugetRuntimeMap[os]} /p:ConfigurationGroup=${configurationGroup} /p:TestWithLocalLibraries=true /p:WithoutCategories=IgnoreForCI")
                         // Tar up the appropriate bits.  On OSX the tarring is a different syntax for exclusion.
                         if (os == 'OSX') {
                             shell("tar -czf bin/build.tar.gz --exclude *.Tests bin/*.${configurationGroup} bin/ref bin/packages")
@@ -639,8 +333,13 @@ def supportedFullCyclePlatforms = ['Windows_NT', 'Ubuntu14.04', 'OSX']
             Utilities.addArchival(newJob, archiveContents)
             // Set up triggers
             if (isPR) {
-                // Set PR trigger.
-                Utilities.addGithubPRTriggerForBranch(newJob, branch, "Innerloop ${os} ${configurationGroup} Build and Test")
+                // Set PR trigger, we run Windows_NT, Ubuntu 14.04, CentOS 7.1 and OSX on every PR.
+                if ( os == 'Windows_NT' || os == 'Ubuntu14.04' || os == 'Centos7.1' || os == 'OSX' ) {
+                    Utilities.addGithubPRTriggerForBranch(newJob, branch, "Innerloop ${os} ${configurationGroup} Build and Test")
+                }
+                else {
+                    Utilities.addGithubPRTriggerForBranch(newJob, branch, "Innerloop ${os} ${configurationGroup} Build and Test", "(?i).*test\\W+innerloop\\W+${os}\\W+${configurationGroup}.*")
+                }
             }
             else {
                 // Set a push trigger
@@ -650,70 +349,4 @@ def supportedFullCyclePlatforms = ['Windows_NT', 'Ubuntu14.04', 'OSX']
     }
 }
 
-// **************************
-// Do some cross platform runs with a debug CoreFX *and* a debug CoreCLR. This reuses some existing jobs we've defined above
-// **************************
-[true, false].each { isPR ->
-    innerLoopNonWindowsOSs.each { os ->
-        def osGroup = osGroupMap[os]
-        def configurationGroup = 'Debug'
-
-        def fullNativeCompBuildJobName = projectFolder + '/' + Utilities.getFullJobName(project, "nativecomp_${os.toLowerCase()}_${configurationGroup.toLowerCase()}", isPR)
-        def fullCoreFXBuildJobName = projectFolder + '/' + Utilities.getFullJobName(project, "${os.toLowerCase()}_${configurationGroup.toLowerCase()}_bld", isPR)
-
-        def newTestJobName = "outerloop_${os.toLowerCase()}_${configurationGroup.toLowerCase()}_checked_coreclr_tst"
-
-        def newTestJob = job(Utilities.getFullJobName(project, newTestJobName, isPR)) { }
-
-        addCopyCoreClrAndRunTestSteps(newTestJob, branch, os, osGroup, fullNativeCompBuildJobName, fullCoreFXBuildJobName, configurationGroup, 'Checked', true, false)
-
-        // Set the affinity.  All of these run on the target
-        Utilities.setMachineAffinity(newTestJob, os, 'latest-or-auto')
-        // Set up standard options.
-        Utilities.standardJobSetup(newTestJob, project, isPR, "*/${branch}")
-        // Add the unit test results
-        Utilities.addXUnitDotNETResults(newTestJob, '**/testResults.xml')
-
-        //
-        // Then we set up a flow job that runs the build and the nativecomp build in parallel and then executes.
-        // the test job
-        //
-        def fullCoreFXTestJobName = projectFolder + '/' + newTestJob.name
-        def flowJobName = "outerloop_${os.toLowerCase()}_${configurationGroup.toLowerCase()}_checked_coreclr"
-        def newFlowJob = buildFlowJob(Utilities.getFullJobName(project, flowJobName, isPR)) {
-            buildFlow("""
-                parallel (
-                    { nativeCompBuild = build(params, '${fullNativeCompBuildJobName}') },
-                    { coreFXBuild = build(params, '${fullCoreFXBuildJobName}') }
-                )
-
-                // Then run the test job
-                build(params +
-                    [COREFX_BUILD: coreFXBuild.build.number,
-                     COREFX_NATIVECOMP_BUILD : nativeCompBuild.build.number], '${fullCoreFXTestJobName}')
-            """)
-
-            // Needs a workspace
-            configure {
-                def buildNeedsWorkspace = it / 'buildNeedsWorkspace'
-                buildNeedsWorkspace.setValue('true')
-            }
-        }
-
-        // Set the affinity.  All of these run on the target
-        Utilities.setMachineAffinity(newFlowJob, os, 'latest-or-auto')
-        // Set up standard options.
-        Utilities.standardJobSetup(newFlowJob, project, isPR, "*/${branch}")
-
-        if (isPR) {
-            // Set PR trigger.
-            Utilities.addGithubPRTriggerForBranch(newFlowJob, branch, "OuterLoop ${os} ${configurationGroup}", "(?i).*test\\W+checked\\W+coreclr\\W+outerloop\\W+${os}.*")
-        }
-        else {
-            // Set a periodic trigger
-            Utilities.addPeriodicTrigger(newFlowJob, '@daily')
-        }
-    }
-}
-
 JobReport.Report.generateJobReport(out)