assert !executer.usesSharedDaemons()
        new XcodebuildExecutor(testDirectory)
    }

    void useXcodebuildTool() {
        executer.requireDaemon().requireIsolatedDaemons()

        def initScript = file("init.gradle")
        initScript << IdeCommandLineUtil.generateGradleProbeInitFile('xcode', 'xcodebuild')

        executer.beforeExecute({

    def setup() {
        expectReindentedValidationMessage()
        // This is required for the daemon to clean up symlinks between builds
        executer.requireDaemon()
        executer.requireIsolatedDaemons()
    }

    def "#desc can handle symlinks"() {
        def buildScript = file("build.gradle")
        def baseDir = file('build')
        baseDir.file('file').text = 'some contents'

            it.taskPath == ":o"
        }
    }

    def "listeners are deregistered after build"() {
        when:
        executer.requireDaemon().requireIsolatedDaemons()
        addSettingsListener()
        buildFile << "task t"
        succeeds("t")

        then:

                includeBuild '../included'
            """
        }

        and:
        // classloader reuse requires daemon reuse without memory pressure
        executer.requireIsolatedDaemons()

        when:
        inDirectory 'root'
        configurationCacheRun ':included:classloader1:probe', ':included:boundary:classloader2:probe'

        then: 'on classloader classloader1'

        when:
        args("--max-workers=${maxWorkers}")
        def gradle = executer.withTasks("parallelWorkTask")
                        .requireIsolatedDaemons()
                        .withWorkerDaemonsExpirationDisabled()
                        .start()

        then:
        handler.waitForAllPendingCalls()

        when:
        handler.release(3)

     *
     * This value is persistent across executions by this executer.
     *
     * <p>Note: this does not affect the Gradle user home directory.</p>
     */
    GradleExecuter requireIsolatedDaemons();

    /**
     * Disable worker daemons expiration.
     */
    GradleExecuter withWorkerDaemonsExpirationDisabled();

    /**

    def "does not leak project state across multiple builds"() {
        fixture.withWorkActionClassInBuildSrc()
        executer.withBuildJvmOpts('-Xms256m', '-Xmx512m').requireIsolatedDaemons().requireDaemon()

        buildFile << """
            ext.memoryHog = new byte[1024*1024*150] // ~150MB

            tasks.withType(WorkerTask) { task ->
                isolationMode = 'processIsolation'

        return snapshotExecution.hash as String
    }

    void enableIdentityCache() {
        // So we don't get a daemon from another test
        executer.requireIsolatedDaemons()
        executer.beforeExecute {
            executer.withArgument("-D$REUSE_USER_HOME_SERVICES=true")
        }
    }

    List<BuildOperationRecord> getTransformExecutions() {

                dependencies {

                    classpath 'org.sample:sub1:1.0'
                }
            }
            task foo
        """

        m1.allowAll()
        executer.requireIsolatedDaemons()
        when:
        run "foo"

        then:
        def op = operations.first(ResolveConfigurationDependenciesBuildOperationType) {

        getBuildContext().gradleHomeDir.copyTo(isolatedGradleHomeDir)
        distribution = new UnderDevelopmentGradleDistribution(getBuildContext(), isolatedGradleHomeDir)
        recreateExecuter()
        executer.requireIsolatedDaemons() //otherwise we might connect to a running daemon from the original installation location
        executer
    }

    /**