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")
    }

                        tasks.create(name, SerialPing)
                    }
                }
            }
        """
        executer.beforeExecute {
            withArgument('--info')
        }
    }

    void withInvalidPing() {
        buildFile << """
            abstract class InvalidPing extends Ping {

    RepositoryServer getServer() {
        return server
    }

    def setup() {
        // SFTP test fixture does not handle parallel resolution requests
        executer.beforeExecute {
            it.withArgument("--max-workers=1")
        }
    }

    public static final String ENABLE_CLI = "-D${PROPERTY_NAME}=true"
    final def fixture = new IsolatedProjectsFixture(this)

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

    void isolatedProjectsRun(String... tasks) {
        run(ENABLE_CLI, *tasks)
    }

    void isolatedProjectsFails(String... tasks) {
        fails(ENABLE_CLI, *tasks)
    }