'init.gradle'("""
                    // init script
                    ${this.instrument('"init"')}
                """)
            }
        }

        when:
        executer.withArgument('-Igradle/init.gradle')
        run 'help'

        then:
        def scripts = scriptDetails()
        scripts.size() == 2
        hasScript('init', scripts)

        executer.inDirectory(dslDir).withArgument("-PmySkipTests")
        def result = succeeds("build")

        then:
        result.assertTaskSkipped(":test")

        when: "run second time to restore from configuration cache if it is enabled"
        executer.inDirectory(dslDir).withArgument("-PmySkipTests")
        def secondResult = succeeds("build")

        then:

            listener.configTime("data")

            task thing {
                doLast { }
            }
        """
        executer.beforeExecute {
            withArgument("--configuration-cache")
            withArgument("-Dorg.gradle.configuration-cache.internal.load-after-store=true")
        }

        when:
        run("thing")

        then:
        output.count("service:") == 2

        then:
        skipped(":someTask")

        // add property
        when:
        buildFile << """
someTask.inputs.property("b", 12)
"""
        and:
        executer.withArgument("-i")
        run "someTask"

        then:
        executedAndNotSkipped(":someTask")
        outputContains("Input property 'b' has been added for task ':someTask'")

        when:

            IGNORE ME
        """

        file("app/src/main/headers/hello.h") << """
            #define GREETING "hello"
        """

        then:
        executer.withArgument("-i")
        succeeds installApp
        output.contains("Cannot locate header file for '#include $include' in source file 'main.cpp'. Assuming changed.")
        install.exec().out == "hello"

                    return null;
                }
            }
        """

        when:
        executer.withArgument('-Porder=0')
        succeeds ":${language.compileTaskName}"

        then:
        noExceptionThrown()

        when: "Order is changed"
        executer.withArgument('-Porder=1')
        fails ":${language.compileTaskName}"

        then:

        when:
        result = executer.inDirectory(firstDir).withTasks('help').withArgument("--build-cache").run()

        then:
        outputContains('my-plugin applied')
        cachedTasks.forEach {
            result.assertTaskExecuted(it)
        }

        when:
        result = executer.inDirectory(secondDir).withTasks('help').withArgument("--build-cache").run()

        then:

        source("class B {}")
        source("class C {}")

        outputs.snapshot { run language.compileTaskName }

        when:
        source("class B { String change; }")
        executer.withArgument "--info"
        run language.compileTaskName

        then:
        outputs.recompiledClasses("A", "B")
    }

    def "can remove source root"() {
        def toBeRemoved = file("to-be-removed")

@TargetCoverage({ CheckstyleCoverage.getSupportedVersionsByJdk() })
class CheckstylePluginToolchainsIntegrationTest extends MultiVersionIntegrationSpec implements JavaToolchainFixture {

    def setup() {
        executer.withArgument("--info")
    }

    def "uses jdk from toolchains set through java plugin"() {
        given:
        goodCode()
        writeDummyConfig()
        def jdk = setupExecutorForToolchains()

        m2.assertNoLeftoverState()

        m2.isolateMavenLocalRepo(executer)
        executer.beforeExecute {
            withArgument("-Dorg.gradle.internal.repository.max.tentatives=$maxHttpRetries")
            if (maxUploadAttempts != null) {
                withArgument("-Dorg.gradle.internal.network.retry.max.attempts=$maxUploadAttempts")
            }
        }
    }

    def cleanup() {