abstract class AbstractAntlrIntegrationTest extends AbstractIntegrationSpec {

    def setup() {
        // So we can assert on which version of ANTLR is used at runtime
        executer.withArgument("-i")
        buildFile << """
            allprojects {
                apply plugin: 'java'
                ${mavenCentralRepository()}
                tasks.withType(JavaCompile) {

    def configureExecuterForToolchains(String... versions) {
        def jdks = AvailableJavaHomes.getJdks(versions)
        Assume.assumeTrue(versions.length == jdks.size())
        executer.beforeExecute {
            withArgument("-Porg.gradle.java.installations.paths=" + jdks.collect { it.javaHome.absolutePath }.join(","))
        }
    }

    }

    TestFile getMetadataCacheDir() {
        return userHomeCacheDir.file(CacheLayout.MODULES.key)
    }

    void markForArtifactCacheCleanup() {
        executer.withArgument("-Dorg.gradle.internal.cleanup.external.max.age=-1")
        TestFile gcFile = metadataCacheDir.file("gc.properties")
        gcFile.createFile()
        assert gcFile.setLastModified(0)
    }

            }
        """

        when:
        withReadOnlyCache()
        latest.rootMetaData.allowGetOrHead()
        expectResolve(latest)
        if (resolveDynamic) {
            executer.withArgument("--refresh-dependencies")
        }

        succeeds ':checkDeps'

        then:
        resolve.expectGraph {
            root(':', 'org.gradle:ro-test:20') {

        executer.beforeExecute(action)
        executer.withArguments("wrapper", "--gradle-distribution-url", distributionUri.toString()).run()
    }

    void prepareWrapper(URI distributionUri = distribution.binDistribution.toURI(), TestKeyStore keyStore) {
        def executer = new InProcessGradleExecuter(distribution, temporaryFolder)
        executer.withArguments(
            "wrapper",
            "--gradle-distribution-url",

        skipped(":javadoc")

        when:
        executer.withArgument("-Ptest.javadoc.version=${jdk2.javaVersion.majorVersion}")
        withInstallations(jdk1, jdk2).run(":javadoc")
        then:
        executedAndNotSkipped(":javadoc")
        file("build/docs/javadoc/Lib.html").text.contains("Some API documentation.")

        when:
        executer.withArgument("-Ptest.javadoc.version=${jdk2.javaVersion.majorVersion}")

            }
        }

        when:
        server.resetExpectations()
        m.pom.expectHead()
        m.moduleMetadata.expectHead()
        m.artifact.expectHead()

        executer.withArgument("--refresh-dependencies")
        run("checkDeps")

        then:
        resolve.expectGraph {
            root(":", ":test:") {
                module("test:a:1.2")
            }
        }
    }

        then:
        !output.contains(DaemonStartupMessage.STARTING_DAEMON_MESSAGE)
    }

    def "the message is not shown when quiet log level is requested"() {
        given:
        executer.withArgument("-q")

        when:
        succeeds()

        then:
        !output.contains(DaemonStartupMessage.STARTING_DAEMON_MESSAGE)
    }

                }
            }
        """

        when:
        def block = server.expectAndBlock("block")
        def client = new DaemonClientFixture(executer.withArgument("--debug").withTasks("block").start())
        block.waitForAllPendingCalls()
        daemons.daemon.assertBusy()
        client.kill()

        then:
        daemons.daemon.becomesCanceled()

        and:

    doLast {
        fileCollection.files
    }
}
"""
        // Ensure build scripts compiled
        run("help")

        when:
        def build1 = executer.withTasks("redThings").withArgument("-Dcrash=true").start()
        build1.waitForFailure()

        run("redThings")

        then:
        output.count("Transforming") == 1
        output.count("Transforming thing.jar to Red") == 1
    }