@Rule BlockingHttpServer server = new BlockingHttpServer()
    boolean killed = false

    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')

@IntegrationTestTimeout(120)
class WorkerDaemonExpirationIntegrationTest extends AbstractIntegrationSpec {

    def setup() {
        given:
        executer.requireIsolatedDaemons()
        executer.requireDaemon()

        and:
        settingsFile << """
            rootProject.name = 'root'
            include 'a', 'b'
        """.stripIndent()
        buildFile << """

                task echo { doLast { println "from distro $i" } }
            }
        """
        distro
    }

    String runWithInstallation(TestFile gradleHome) {
        toolingApi.requireIsolatedDaemons()
        toolingApi.withConnector { GradleConnector it ->
            it.useInstallation(new File(gradleHome.absolutePath))
        }
        withBuild { it.forTasks("echo") }.standardOutput
    }

     * This difference leads to different up-to-date messages, which is why we force
     * a consistent execution mode.
     */
    def setup() {
        executer.requireDaemon().requireIsolatedDaemons()
        executer.beforeExecute {
            noDeprecationChecks()
        }
    }

    def "not up-to-date when default Java version changes"() {
        given:
        buildFile << """

    def customGradleUserHomeDir = testDirectoryProvider.getTestDirectory().file('user-home')
    def markerFile
    def welcomeMessage

    def setup() {
        executer.requireDaemon().requireIsolatedDaemons()
        executer.withGradleUserHomeDir(customGradleUserHomeDir)
        executer.withWelcomeMessageEnabled()

        then:
        assertCauseWithStacktrace('show stacktrace was ALWAYS')
    }

    def "emits actionable message when wrong configuration is used"() {
        setup:
        executer.requireDaemon().requireIsolatedDaemons()
        file('gradle.properties') << 'org.gradle.logging.stacktrace=suppress'

        when:
        fails()

        then:

            assert !gradle.isRunning()
        }
    }

    def "does not log daemon cancel message for continuous build"() {
        setup:
        executer.requireDaemon()
        executer.requireIsolatedDaemons()
        setupJavaProject()

        when:
        succeeds("build")

        and:
        sendEOT()

        then:
        ConcurrentTestUtil.poll(buildTimeout, 0.5) {

        // the installed distro is deleted at the end of this test
        executer.requireIsolatedDaemons()
        return executer
    }

class JavaExecJavaVersionIntegrationSpec extends AbstractIntegrationSpec {

    def setup() {
        // Without this, executing the JavaExec tasks leave behind running daemons.
        executer.requireDaemon().requireIsolatedDaemons()
    }

    @Requires([IntegTestPreconditions.LowestSupportedLTSJavaHomeAvailable, IntegTestPreconditions.HighestSupportedLTSJavaHomeAvailable ])
    def "up-to-date when executing twice in a row"() {
        given:

class GroovyToJavaConversionIntegrationTest extends AbstractIntegrationSpec {

    def "For every boolean is getter there is a get Getter"() {
        given:
        executer.requireDaemon().requireIsolatedDaemons() // We need to fork - if we do not fork Class-Decoration does not happen

        when:
        def convertedClasses = this.getClass().getResource( '/org/gradle/initialization/converted-types.txt' ).readLines()