public static boolean isConfigCache() {
        Executer executer = getSystemPropertyExecuter();
        return executer == Executer.configCache || executer == Executer.isolatedProjects;
    }

    public static boolean isNotIsolatedProjects() {
        return !isIsolatedProjects();
    }

    public static boolean isIsolatedProjects() {
        return getSystemPropertyExecuter() == Executer.isolatedProjects;
    }

            executer.withTasks("d").withArguments("-x", ":sub:c").run().assertTasksExecuted(":a", ":b", ":c", ":d", ":sub:d")
            executer.withTasks("d").withArguments("-x", "d").run().assertTasksExecuted()
            // Project defaults

        executer.gradleUserHomeDir.file('init.gradle') << 'println "greetings from user home"'

        when:
        run()

        then:
        output.contains("greetings from user home")
    }

    def "executes init scripts from init.d directory in user home dir in alphabetical order"() {
        given:
        executer.requireOwnGradleUserHomeDir()

        and:

import org.gradle.integtests.fixtures.executer.ArtifactBuilder;
import org.gradle.integtests.fixtures.executer.GradleBackedArtifactBuilder;
import org.gradle.integtests.fixtures.executer.GradleContextualExecuter;
import org.gradle.integtests.fixtures.executer.GradleDistribution;
import org.gradle.integtests.fixtures.executer.GradleExecuter;
import org.gradle.integtests.fixtures.executer.InProcessGradleExecuter;

import org.gradle.integtests.fixtures.executer.ArtifactBuilder
import org.gradle.integtests.fixtures.executer.ExecutionFailure
import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.integtests.fixtures.executer.GradleBackedArtifactBuilder
import org.gradle.integtests.fixtures.executer.GradleContextualExecuter
import org.gradle.integtests.fixtures.executer.GradleDistribution

        def executer = wrapperExecuter(wrapperVersion)
        executer
    }

    private GradleExecuter wrapperExecuter(GradleDistribution wrapper) {
        def executer = super.version(wrapper)

        if (!wrapper.supportsSpacesInGradleAndJavaOpts) {
            // Don't use the test-specific location as this contains spaces

    val defaultExecuter = "embedded"

    // For all the other executers, add an executer specific task
    testType.executers.forEach { executer ->
        val taskName = "$executer${prefix.capitalize()}Test"
        val testTask = createTestTask(taskName, executer, sourceSet, testType) {}
        if (executer == defaultExecuter) {
            // The test task with the default executer runs with 'check'

    }

    @UsesSample("testing/filtering")
    def "can execute a subset of tests with filtering with #dsl dsl"() {
        given:
        TestFile dslDir = sample.dir.file(dsl)
        executer.inDirectory(dslDir)

        when:
        def result = succeeds("test")

        then: "the test task is executed"
        result.assertTaskExecuted(":test")

import org.gradle.integtests.fixtures.executer.GradleContextualExecuter
import org.gradle.integtests.fixtures.executer.GradleExecuter
import org.gradle.integtests.fixtures.executer.InitScriptExecuterFixture
import org.gradle.test.fixtures.file.TestDirectoryProvider


class ZincScalaCompileFixture extends InitScriptExecuterFixture {
    ZincScalaCompileFixture(GradleExecuter executer, TestDirectoryProvider testDir) {

import org.gradle.integtests.fixtures.executer.ExecutionResult


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

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