@Rule BlockingHttpServer server = new BlockingHttpServer()

    def "receive task 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 "uses jdk from toolchains set through java plugin"() {
        given:
        def jdk = setupExecutorForToolchains()
        assumeToolchainJdkIsCompatibleWithCodeNarcVersion(jdk.javaVersion)

        and:
        goodCode()
        writeRuleFile()
        writeBuildFileWithToolchainsFromJavaPlugin(jdk)

        when:
        succeeds("codenarcMain")

        then:

    void setup() {
        toolingApi.requireIsolatedDaemons()
    }

    def "should received failed event when daemon disappears unexpectedly with TAPI higher 2.4"() {
        given:
        goodCode()
        def sync = server.expectAndBlock('sync')

        when:
        def result = []
        withConnection { ProjectConnection connection ->

        given:
        goodCode()
        badJavaCode()

        and:
        buildFile << "compileScala.options.failOnError = false\n"

        expect:
        succeeds 'compileScala'
    }

    def "joint compile bad java code do not fail the build when scalaCompileOptions.failOnError is false"() {
        given:
        goodCode()
        badJavaCode()

        and:

@TargetCoverage({ CheckstyleCoverage.getSupportedVersionsByJdk() })
class CheckstylePluginClasspathIntegrationTest extends MultiVersionIntegrationSpec {
    def setup() {
        writeBuildFiles()
        writeConfigFile()
        goodCode()
    }

    def "accepts throwing exception from other project"() {
        expect:
        succeeds("checkstyleMain")
    }

    private void writeBuildFiles() {
        file("settings.gradle") << """

import org.gradle.util.internal.VersionNumber
import spock.lang.Issue

class AntWorkerMemoryLeakIntegrationTest extends AbstractIntegrationSpec {
    public static final String LOCAL_GROOVY = 'localGroovy()'

    private void goodCode(String groovyVersion, TestFile root = testDirectory) {
        root.file("src/main/java/org/gradle/Class0.java") << "package org.gradle; public class Class0 { }"

        writeRuleFile()
    }

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

        expect:
        succeeds("check")
        report("main").exists()
        report("test").exists()
    }

    @Requires(IntegTestPreconditions.NotParallelExecutor)
    def "is incremental"() {
        given:
        goodCode()

        expect:
        succeeds("codenarcMain")

        given:
        goodJavaInterfaceCode()
        goodCodeUsingJavaInterface()

        expect:
        succeeds 'compileScala', '-s'
    }

    def "can generate ScalaDoc"() {
        given:
        goodCode()

        expect:
        succeeds("scaladoc")
        file("build/docs/scaladoc/compile/test/Person.html").assertExists()
    }

<module name="Checker">
    <module name="TreeWalker">
        <module name="$nameOfCheck"/>
    </module>
</module>
        """
    }

    private void goodCode() {
        file("src/main/java/com/example/Foo.java").java """
            package com.example;

            public class Foo {
                /**
                 * This returns a bar.
                 *

class TestProgressCrossVersionSpec extends ToolingApiSpecification implements WithOldConfigurationsSupport {
    def "receive test progress events when requesting a model"() {
        given:
        goodCode()

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