setupProjectIn(relocatedDir)

        //We'll delete the relocated Java home of this daemon, which will make it unusable for future builds
        executer.requireDaemon().requireIsolatedDaemons()

        when: "task is built in the original location"
        inDirectory(originalDir)
        executer.withJavaHome(originalJavaHome)
        withBuildCache().run taskName

                    println "defaultLocale: " + Locale.default
                }
            }
        """

        when:
        executer.requireIsolatedDaemons()
        executer.withGradleVersionOverride(DefaultGradleVersion.version(overrideVersion))
        runWithLocale(locale)

        then:

            }

            task task(type: SubclassTask)
        """

        then:
        version previous withTasks 'assemble' inDirectory(file("producer")) run()
        version current requireDaemon() requireIsolatedDaemons() withTasks 'task' run()
    }

        cleanup:
        stopDaemonsNow()
    }

    def "uses defaults for max/min heap size when JAVA_TOOL_OPTIONS is set (#javaToolOptions)"() {
        setup:
        executer.requireDaemon().requireIsolatedDaemons()
        boolean java9orAbove = JavaVersion.current().java9Compatible

        buildScript """
            import java.lang.management.ManagementFactory
            import java.lang.management.MemoryMXBean

import java.nio.file.Files

class BuildActionCrossVersionSpec extends ToolingApiSpecification {
    def "can change the implementation of an action"() {
        // Make sure we reuse the same daemon
        toolingApi.requireIsolatedDaemons()

        disableJarCachingWhenUsingOldGradleVersion()

        def workDir = temporaryFolder.file("work")
        def implJar = workDir.file("action-impl.jar")

    abstract String getApplyAndConfigure()

    abstract TestJvmComponent getComponent()

    def setup() {
        executer.withWorkerDaemonsExpirationDisabled()
        executer.requireDaemon().requireIsolatedDaemons()
        buildFile << """
            import org.gradle.workers.internal.WorkerDaemonClientsManager
            import org.gradle.workers.internal.DaemonForkOptions

            allprojects {

                    println("*" + it.name + "*")
                }
            }
            """
        )

        executer.withGradleUserHomeDir(guh)
        executer.requireIsolatedDaemons()

        assertThat(
            build().output,
            containsString("*test-repository*")
        )
    }

    @Test

}

project('resolve') {
    task resolve {
        doLast {
            configurations.compileClasspath.files.collect { it.file }
        }
    }
}
"""
        executer.requireOwnGradleUserHomeDir().requireIsolatedDaemons()

        expect:
        def build = executer.withArguments('query:query', ':resolve:resolve', '--parallel').start()

        handler.waitForAllPendingCalls()
        handler.release('/sync')

                .withArgument("-Porg.gradle.java.installations.paths=$invalidJdkHome1.canonicalPath,$invalidJdkHome2.canonicalPath,$existingJdk.javaHome.absolutePath")
                .withArgument("--info")
                .requireIsolatedDaemons()
                .withStackTraceChecksDisabled() // expect the info logs from JVM metadata detector to contain the stack trace
                .withTasks(":sub1:exec", ":sub2:exec")
                .run()
        }

import spock.lang.Issue

class BuildSrcPluginIntegrationTest extends AbstractIntegrationSpec {

    @Issue("GRADLE-2001")
    def "can use plugin from buildSrc that changes"() {
        given:
        executer.requireIsolatedDaemons() // make sure we get the same daemon both times

        buildFile << "apply plugin: 'test-plugin'"

        file("buildSrc/settings.gradle") << "include 'testplugin'"