given:
        goodCode()
        goodTests()
        failingDependenciesForTestTask()

        when:
        runAndFail('check')

        then:
        !buildDashboardFile.exists()
    }

    void 'build dashboard is not generated if a dependency of the report generating task fails even with --continue'() {
        given:
        goodCode()
        goodTests()

        buildFile << 'pmd { incrementalAnalysis = false }'
        goodCode()

        expect:
        succeeds("check", "-i")
        !file("build/tmp/pmdMain/incremental.cache").exists()
    }

    def "incremental analysis can be enabled"() {
        given:
        Assume.assumeTrue(supportIncrementalAnalysis())
        goodCode()

        when:
        succeeds("pmdMain")

        then:

                options.compilerArgs << '-Xlint:all,-options' << '-Werror'
            }
        """
        buildFile << compilerConfiguration()
    }

    def "can compile good code"() {
        given:
        goodCode()

        when:
        succeeds("compileJava")

        then:
        output.contains(logStatement())
        javaClassFile("compile/test/Person.class").exists()
    }

class ProgressCrossVersionSpec extends ToolingApiSpecification implements WithOldConfigurationsSupport {

    def "receive progress events when requesting a model"() {
        given:
        goodCode()

        when: "asking for a model and specifying some task(s) to run first"
        def events = ProgressEvents.create()
        withConnection {
            ProjectConnection connection ->

class BuildProgressCrossVersionSpec extends ToolingApiSpecification implements WithOldConfigurationsSupport {

    def "receive build progress events when requesting a model"() {
        given:
        goodCode()

        when: "asking for a model and specifying some task(s) to run first"
        def events = ProgressEvents.create()
        withConnection {
            ProjectConnection connection ->

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

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

        when:
        succeeds("checkstyleMain")

        then:

    @Rule
    public final Resources resources = new Resources()

    def setup() {
        writeBuildFile()
        writeConfigFile()
    }

    def "analyze good code"() {
        goodCode()

        expect:
        succeeds('check')
        file("build/reports/checkstyle/main.sarif").assertDoesNotExist()
        file("build/reports/checkstyle/test.sarif").assertDoesNotExist()

    }

    @Override
    String logStatement() {
        "compiler daemon"
    }

    def setup() {
        executer.withArguments("-d")
    }

    def "respects fork options settings"() {
        goodCode()
        buildFile << """
            import org.gradle.workers.internal.WorkerDaemonClientsManager
            import org.gradle.internal.jvm.Jvm

            tasks.withType(JavaCompile) {

        goodCode()
        buildFile << """
        pmdMain {
            rulesMinimumPriority = 11
        }
"""
        expect:
        fails("check")
        failure.assertHasCause("Invalid rulesMinimumPriority '11'.  Valid range 1 (highest) to 5 (lowest).")
    }

    def "can configure reporting"() {
        goodCode()
        buildFile << """
            pmdMain {

        given:
        goodCode()
        writeBuildFile()

        when:
        succeeds("pmdMain")

        then:
        outputContains("Running pmd with toolchain '${Jvm.current().javaHome.absolutePath}'")
    }

    def "uses current jdk if pmd plugin is not applied"() {
        given:
        goodCode()
        setupExecutorForToolchains()