then:
        outputs.recompiledClasses("A")
    }

    def "classpath analysis is restored from the build cache"() {
        requireOwnGradleUserHomeDir().requireDaemon().requireIsolatedDaemons()
        buildFile << "dependencies { implementation 'org.apache.commons:commons-lang3:3.8' }\n"
        source("class A {}")
        withBuildCache().run language.compileTaskName
        executer.stop()

import org.gradle.integtests.tooling.fixture.ToolingApiSpecification

class DaemonReuseCrossVersionSpec extends ToolingApiSpecification {
    GradleExecuter executer

    def setup() {
        toolingApi.requireIsolatedDaemons()
        executer = toolingApi.createExecuter()
        executer.useOnlyRequestedJvmOpts()
        settingsFile << "rootProject.name = 'test-build'"
    }

abstract class AbstractCompilerContinuousIntegrationTest extends AbstractContinuousIntegrationTest {

    def setup() {
        executer.withWorkerDaemonsExpirationDisabled()
        executer.requireIsolatedDaemons()
    }

    abstract String getCompileTaskName()
    abstract String getCompileTaskType()
    abstract String getSourceFileName()
    abstract String getInitialSourceContent()

import org.gradle.integtests.fixtures.executer.ExecutionFailure

class InternalGradleFailuresIntegrationTest extends AbstractIntegrationSpec {

    def setup() {
        executer.requireIsolatedDaemons()
        executer.requireOwnGradleUserHomeDir()
        executer.requireDaemon()

        buildScript """
            task hello() {
                doLast {
                    println "Hello Gradle!"

import org.gradle.integtests.fixtures.AbstractIntegrationSpec

class ClassLoaderLeakAvoidanceSoakTest extends AbstractIntegrationSpec {

    def setup() {
        executer.requireDaemon().requireIsolatedDaemons()
    }

    def "convention mapping does not leak old classloaders"() {
        given:
        def myTask = file("buildSrc/src/main/groovy/MyTask.groovy") << """
            import org.gradle.api.*

}

apply plugin: SomePlugin
"""

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

                }
            }
        """

        expect:
        version previous withTasks 'publish' inDirectory(file("plugin")) run()
        version current requireDaemon() requireIsolatedDaemons() withTasks 'sofExec' run()
    }

class ContinuousBuildFileWatchingIntegrationTest extends AbstractContinuousIntegrationTest implements FileSystemWatchingFixture {

    def setup() {
        executer.requireIsolatedDaemons()
    }

    def "file system watching picks up changes causing a continuous build to rebuild"() {
        given:
        // Do not drop the VFS in the first build, since there is only one continuous build invocation.

            executer.withArgument(it)
        }
        executer.run()
    }

    GradleExecuter getWrapperExecuter() {
        executer.requireOwnGradleUserHomeDir()
        executer.requireIsolatedDaemons()
        executer.beforeExecute {
            executer.usingExecutable("gradlew")
        }
        return executer
    }

import static org.gradle.integtests.fixtures.ToBeFixedForConfigurationCache.Skip.INVESTIGATE

class AntBuilderLoggingIntegrationTest extends AbstractIntegrationSpec {
    def setup() {
        executer.requireIsolatedDaemons()
        buildFile """
            ant.saveStreams = false
            task antTest {
                doLast {
                    ant.echo(message: "VERBOSE message", level: "verbose")