* limitations under the License.
 */

package org.gradle.testkit.runner

import org.gradle.integtests.fixtures.versions.ReleasedVersionDistributions
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.UnitTestPreconditions
import org.gradle.testkit.runner.fixtures.Debug
import org.gradle.testkit.runner.fixtures.NonCrossVersion

        "org.apache.commons:commons-math3": {
            "locked": "3.6.1",
            "requested": "3.6.1"
        }
    }
}'''

        then:
        runner('dependencies').build()
        runner('generateLock').build()
        runner('resolve').build()

        where:
        version << TestedVersions.nebulaDependencyLock
    }

        when:
        runner = runnerForLocation(
            checkoutDir, agpVersion,
            "common:lintDebug", "playgames:lintDebug", "doodles-lib:lintDebug"
        )
        SantaTrackerConfigurationCacheWorkaround.beforeBuild(checkoutDir, homeDir)
        runner.withArguments(runner.arguments + "--continue")
        result = runner.buildAndFail()

        then:

    def "clean assemble with parallel workers"() {
        given:
        runner.testGroup = 'parallel builds'
        runner.buildSpec {
            displayName("parallel")
            invocation {
                tasksToRun("clean", "assemble")
            }
        }
        runner.baseline {
            displayName("serial")
            invocation {
                tasksToRun("clean", "assemble")

    ])
    def "#tasks with rich console"() {
        given:
        runner.tasksToRun = tasks.split(' ')
        runner.warmUpRuns = 5
        runner.runs = 8

        when:
        def result = runner.run()

        then:
        result.assertCurrentVersionHasNotRegressed()

        where:
        tasks << ['clean assemble', 'cleanTest test']

class SwiftCleanBuildPerformanceTest extends AbstractCrossVersionPerformanceTest {

    def setup() {
        runner.minimumBaseVersion = '4.6'
    }

    def "clean assemble (swift)"() {
        given:
        runner.tasksToRun = ["assemble"]
        runner.cleanTasks = ["clean"]

        when:
        def result = runner.run()

        then:
        result.assertCurrentVersionHasNotRegressed()
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.testkit.runner.enduser

import groovy.io.FileType
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.IntegTestPreconditions
import org.gradle.testkit.runner.fixtures.NoDebug
import org.gradle.testkit.runner.internal.DefaultGradleRunner
import org.gradle.util.internal.GFileUtils

        file("src/test/java/FooTest.java") << """
            import org.junit.*;
            import org.junit.runner.*;
            @RunWith(SomeRunner.class)
            public class FooTest {
            }
        """.stripIndent()
        file("src/test/java/SomeRunner.java") << """
            import org.junit.*;
            import org.junit.runner.*;

        buildFile.writeText("""
            plugins {
                id 'org.example.my-plugin'
            }
        """)

        runner()
            .withArguments("--configuration-cache", "myTask")        // <1>
            .build()

        val result = runner()
            .withArguments("--configuration-cache", "myTask")        // <2>
            .build()

        @Scenario(type = PER_DAY, operatingSystems = [LINUX], testProjects = ["largeJavaMultiProject", "largeMonolithicJavaProject"])
    )
    def "tasks"() {
        given:
        runner.tasksToRun = ['tasks']

        when:
        def result = runner.run()

        then:
        result.assertCurrentVersionHasNotRegressed()
    }

    @RunFor(