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

    void stopDaemonsNow() {
        result = executer.withArguments("--stop", "--info").run()
    }

    void buildSucceeds() {
        result = executer.withArguments("--info").run()
    }

    DaemonsFixture getDaemons() {
        new DaemonLogsAnalyzer(executer.daemonBaseDir)
    }

        file('settings.gradle') << 'include "a", "b", "c"'
        buildFile << '''
allprojects {
    apply plugin: 'java'
    task fooTask
    task barTask
}
'''
        when:
        executer.withArgument("--profile")
        succeeds("build", "fooTask", "-x", "barTask")

        then:
        def reportFile = findReport()
        Document document = Jsoup.parse(reportFile, null)

            plugins {
                id("my-project-plugin")
            }
        """
        return version(distribution)
            .inDirectory(file("consumer"))
            .withArgument("-I")
            .withArgument("init.gradle.kts")
            .withTasks("myTask")
            .run()
    }

        executedAndNotSkipped ":b:compileGroovy"
    }

    def "recompile with change of local ast transformation"() {
        given:
        executer.beforeExecute {
            executer.withArgument('--info')
        }
        buildFile << astTransformationDeclaration()
        file("a/src/main/groovy/MyAnnotation.groovy") << astTransformationAnnotation()

        when: "running two consecutive builds in a daemon"
        def results = (0..1).collect {
            executer
                .withArgument("-Porg.gradle.java.installations.paths=$invalidJdkHome1.canonicalPath,$invalidJdkHome2.canonicalPath,$existingJdk.javaHome.absolutePath")
                .withArgument("--info")
                .requireIsolatedDaemons()

        previousExecuter.withArgument("-Penable-block1")
        previousExecuter.withTasks("c")
        def build1 = previousExecuter.start()
        block1.waitForAllPendingCalls()

        // Start build 2 then wait until it has run both 'a' and 'b'.
        def currentExecuter = version(current)
        currentExecuter.withArgument("-Penable-block2")
        currentExecuter.withTasks("c")

class MavenToolchainsIntegrationTest extends AbstractIntegrationSpec {
    def "logs at info level when invalid toolchain file is provided"() {
        def toolchainsFile = file("toolchains.xml")
        executer.withArgument("-Porg.gradle.java.installations.maven-toolchains-file=${TextUtil.escape(toolchainsFile.absolutePath)}")
        executer.withToolchainDetectionEnabled()
        toolchainsFile << "not xml"

        when:

        setupSubproject("subproject2", "Bar", otherJdkMetadata)

        when:
        result = executer
                .withTasks("compileJava")
                .withArgument("--info")
                .run()


        then:
        result.plainTextOutput.matches("(?s).*Compiling with toolchain.*${DefaultJdkCacheDirectory.getInstallFolderName(jdkMetadata)}.*")

@SelfType(AbstractIntegrationSpec)
trait IsolatedProjectsExecuterFixture {

    private static final String ENABLE_CLI = "-D${PROPERTY_NAME}=true"

    void withIsolatedProjects() {
        executer.withArgument(ENABLE_CLI)
    }

        run("a")

        then:
        result.assertTaskSkipped(":a")

        when:
        executer.withArgument("-Dname=b")
        run("a")

        then:
        result.assertTaskNotSkipped(":a")
        file("out.txt").text == "b"

        when:
        executer.withArgument("-Dname=b")
        run("a")

        then:
        result.assertTaskSkipped(":a")
    }