import org.gradle.util.ports.DefaultPortDetector
import org.gradle.util.ports.FixedAvailablePortAllocator
import org.junit.Assume
import org.junit.rules.TestRule
import org.junit.runner.Description
import org.junit.runners.model.Statement

/**
 * A utility for communicating with a VM in debug mode using JDWP.
 */
class JDWPUtil implements TestRule {
    String host
    Integer port
    def vm

    ])
    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']

package org.gradle.sample

import org.gradle.testkit.runner.GradleRunner
import spock.lang.TempDir
import spock.lang.Specification

import static org.gradle.testkit.runner.TaskOutcome.*

class BuildLogicFunctionalTest extends Specification {

    @TempDir File testProjectDir
    File settingsFile
    File buildFile

    def setup() {
        settingsFile = new File(testProjectDir, 'settings.gradle')

package org.gradle.sample

// tag::functional-test-spock-gradle-version[]
import org.gradle.testkit.runner.GradleRunner
import static org.gradle.testkit.runner.TaskOutcome.*
import spock.lang.TempDir
import spock.lang.Specification

class BuildLogicFunctionalTest extends Specification {
    @TempDir File testProjectDir
    File settingsFile
    File buildFile

    def setup() {
        settingsFile = new File(testProjectDir, 'settings.gradle')

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

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

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

 * limitations under the License.
 */

package org.gradle.testkit.runner


import org.gradle.testkit.runner.internal.DefaultGradleRunner
import org.gradle.util.GradleVersion
import org.junit.Assume

class GradleRunnerIsolationIntegrationTest extends BaseGradleRunnerIntegrationTest {

    def "configuration in gradle user home is not used by gradle runner builds"() {
        when:

    def buildOperationExecutor = Mock(BuildOperationExecutor)
    def buildModelParameters = Mock(BuildModelParameters)
    def runner = new IntermediateBuildActionRunner(buildOperationExecutor, buildModelParameters, "Test operation")

    def "parallelism is defined by Tooling API parallel actions"() {
        when:
        runner.isParallel()

        then:
        1 * buildModelParameters.isParallelToolingApiActions() >> true
        0 * _
    }

    def setup() {
        runner.cleanTasks = ["clean"]
        runner.args = ["-D${StartParameterBuildOptions.BuildCacheOption.GRADLE_PROPERTY}=true"]
        buildCacheServer.logRequests = false
        cacheDir = temporaryFolder.file("local-cache")
        runner.addBuildMutator { invocationSettings ->
            new BuildMutator() {
                @Override

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

        when:
        def result = runner.run()

        then:
        result.assertCurrentVersionHasNotRegressed()
    }

    @RunFor(

import org.gradle.internal.declarativedsl.evaluator.runner.EvaluationResult
import org.gradle.internal.declarativedsl.evaluator.runner.AnalysisStepContext
import org.gradle.internal.declarativedsl.evaluator.runner.AnalysisStepResult
import org.gradle.internal.declarativedsl.evaluator.runner.InterpretationSequenceStepRunner
import org.gradle.internal.declarativedsl.evaluator.runner.StepContext