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

            }

            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

}

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

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'"

            overridden_by_includedBuild=included
        '''.stripIndent()

        version(wrapperVersion).withTasks('wrapper').run()

        when:
        GradleExecuter executer = version(wrapperVersion).requireIsolatedDaemons()
        String output = executer.usingExecutable('gradlew').withTasks('hello').run().output

        then:
        output.contains('system_property_available in buildSrc:                 true')

class SingleUseDaemonIntegrationTest extends AbstractIntegrationSpec implements DaemonJvmPropertiesFixture, JavaToolchainFixture {

    def setup() {
        executer.withArgument("--no-daemon")
        executer.requireIsolatedDaemons()
    }

    def "forks build when JVM args are requested"() {
        requireJvmArg('-Xmx64m')

        file('build.gradle') << "println 'hello world'"

        when:
        succeeds()

    def setup() {
        //these meta tests mess with the daemon log: do not interfere with other tests when running in parallel
        toolingApi.requireIsolatedDaemons()
    }

    def iteration = 0

    def "does not retry if NPE is thrown in daemon registry in >=1.8"() {
        given:
        iteration++

        when:

        false
    }

    boolean isResolveDynamic() {
        false
    }

    abstract List<MavenHttpModule> getModulesInReadOnlyCache(MavenHttpRepository repo)

    def setup() {
        executer.requireIsolatedDaemons()
        executer.requireOwnGradleUserHomeDir()
        def roModules = getModulesInReadOnlyCache(mavenHttpRepo)
        roModules.each {
            it.withModuleMetadata()

                    URLConnection urlConnection = url.openConnection()
                    assert urlConnection.defaultUseCaches
                }
            }
        """
        executer.requireDaemon().requireIsolatedDaemons()

        expect:
        succeeds("checkUrlConnectionCaching")
    }

    def "jars with resources on buildscript classpath can change"() {
        given:
        buildFile << '''