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

    def setup() {
        executer.requireIsolatedDaemons()
    }

abstract class AbstractDaemonWorkerExecutorIntegrationSpec extends AbstractWorkerExecutorIntegrationTest {
    def setup() {
        executer.requireDaemon()
        executer.requireIsolatedDaemons()
    }

    @Override
    protected ExecutionResult succeeds(String... tasks) {
        executer.withWorkerDaemonsExpirationDisabled()
        return super.succeeds(tasks)
    }

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

    def setup() {
        assumeFalse("No shared state without a daemon", GradleContextualExecuter.noDaemon)

        // Make the first build in each test drop the VFS state
        executer.requireIsolatedDaemons()
    }

    static String sourceFileWithGreeting(String greeting) {
        """
            public class Main {
                public static void main(String... args) {

                    events "passed", "skipped", "failed"
                }
            }
        """.stripIndent()

        when:
        executer
            .requireDaemon()
            .requireIsolatedDaemons()
            .withBuildJvmOpts("-Duser.language=tr", "-Duser.country=TR")
            .withTasks("help")
            .run()

        then:
        noExceptionThrown()
    }

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()
    }

    def "caches native binaries in specified user home"() {
        given:
        executer.withNoExplicitNativeServicesDir()
        executer.requireOwnGradleUserHomeDir()
        executer.requireDaemon().requireIsolatedDaemons()

        when:
        succeeds "help"

        then:
        executer.gradleUserHomeDir.file("native").assertIsDir()
    }

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

class JavaCompilationSoakTest extends AbstractIntegrationSpec {
    def setup() {
        // projectCount * memoryHog ~= 25% default JVM heap size
        def projectCount = 5
        executer.requireIsolatedDaemons()

        def subprojects = []
        projectCount.times {
            subprojects << "sub" + it
        }
        multiProjectBuild("root", subprojects) {
            buildFile << """