@Requires(IntegTestPreconditions.NotParallelExecutor)
    def "reasonable failure message when --max-workers=#value"() {
        given:
        executer.requireDaemon().requireIsolatedDaemons()  // otherwise exception gets thrown in testing infrastructure

        when:
        executer.withArgument("--max-workers=$value")

        then:
        fails "help"

        and:

    }

    def "task can use all methods declared by Task interface that AbstractTask specialises"() {
        given:
        prepareMethodUseTest(previous.version)

        expect:
        version previous withTasks 'assemble' inDirectory(file("producer")) run()
        version current requireDaemon() requireIsolatedDaemons() withTasks 't' run()
    }

    }

    def "task can use all methods declared by Task interface that AbstractTask specialises"() {
        given:
        prepareMethodUseTest(current.version)

        expect:
        version current withTasks 'assemble' inDirectory(file("producer")) run()
        version previous requireDaemon() requireIsolatedDaemons() withTasks 't' run()
    }

    @Requires(
        value = IntegTestPreconditions.IsDaemonExecutor,
        reason = "Testing the daemons"
    )
    def "daemon with the same agent status is reused"() {
        given:
        executer.requireIsolatedDaemons()
        withDumpAgentStatusTask()

        when:
        withAgentApplied(useAgentOnFirstRun)
        succeeds()

        then:
        daemons.daemon.becomesIdle()

        when:

        given:
        file('.myGradle').createDir()
        file('build.gradle') << "assert gradle.gradleUserHomeDir.name.endsWith('.myGradle')"
        toolingApi.requireIsolatedDaemons()

        when:
        withConnection {
            it.newBuild().withArguments('-g', '.myGradle').run()
        }

        then:
        noExceptionThrown()
    }

 */
@Requires(IntegTestPreconditions.IsLongLivingProcess)
class PersistentBuildProcessIntegrationTest extends AbstractIntegrationSpec {

    def setup() {
        executer.requireIsolatedDaemons()
    }

        if (executerType == Executer.embedded && !Charset.forName(defaultCharacterEncoding).equals(Charset.defaultCharset())) {
            // need to fork to apply the new default character encoding
            requireDaemon().requireIsolatedDaemons();
        }
        return super.withDefaultCharacterEncoding(defaultCharacterEncoding);
    }

    @Override
    public GradleExecuter withDefaultLocale(Locale defaultLocale) {

import org.gradle.test.fixtures.ConcurrentTestUtil

abstract class DaemonIntegrationSpec extends AbstractIntegrationSpec {
    def setup() {
        executer.requireDaemon()
        executer.requireIsolatedDaemons()
    }

    void stopDaemonsNow() {
        result = executer.withArguments("--stop", "--info").run()
    }

    void buildSucceeds() {
        result = executer.withArguments("--info").run()
    }

package org.gradle

import org.gradle.test.fixtures.file.TestFile

class BinDistributionIntegrationSpec extends DistributionIntegrationSpec {

    def setup() {
        executer.requireOwnGradleUserHomeDir().requireIsolatedDaemons()
    }

    @Override
    String getDistributionLabel() {
        "bin"
    }

    @Override
    int getMaxDistributionSizeBytes() {
        return 135 * 1024 * 1024
    }

class BuildFailureIntegrationTest extends AbstractIntegrationSpec {
    def "still prints errors when exception misbehaves"() {
        // When running in-process, the NPE propagates out of the test fixtures
        executer.requireIsolatedDaemons()
        executer.requireDaemon()

        buildFile << """
class BadException extends Exception {
   String getMessage() {
     throw new NullPointerException()
   }
}

throw new BadException()