*/
    GradleDistribution getDistribution();

    /**
     * Copies the settings from this executer to the given executer.
     *
     * @param executer The executer to copy to
     * @return The passed in executer
     */
    GradleExecuter copyTo(GradleExecuter executer);

    /**
     * Where possible, starts the Gradle build process in debug mode with the provided options.
     */

        .body("def")
        .throttleBody(1, 750, TimeUnit.MILLISECONDS)
        .build(),
    )
    val call = client.newCall(Request(server.url("/a")))
    val executor = Executors.newSingleThreadExecutor()
    val result = executor.submit<Response?> { call.execute() }
    Thread.sleep(100) // wait for it to go in flight.
    call.cancel()
    assertFailsWith<IOException> {
      result.get()!!.body.bytes()

        this.workerLimits = workerLimits;
        this.workerLeaseService = workerLeaseService;
        this.executor = executorFactory.create(displayName);

        executor.setKeepAlive(KEEP_ALIVE_TIME_MS, TimeUnit.MILLISECONDS);
    }

    @Override
    public void submit(ConditionalExecution<T> execution) {
        if (queueState == QueueState.Stopped) {

            module == 'test'
            version == '4.2'
        }

        List<BuildOperationRecord> executions = getTransformExecutions()
        executions.size() == 2
        def projectExecution = executions.find { it.details.identity == projectTransformIdentification.identity }
        def externalExecution = executions.find { it.details.identity == externalTransformIdentification.identity }

    }

    GradleExecuter version(GradleDistribution dist) {
        def executer = dist.executer(temporaryFolder, IntegrationTestBuildContext.INSTANCE)
        if (gradleUserHomeDir) {
            executer.withGradleUserHomeDir(gradleUserHomeDir)
        }
        executer.inDirectory(testDirectory)
        executers << executer
        return executer
    }

        then:
        outputContains("Test executor initialized Native services: false")
        outputContains("Build inside a test executor initialized Native services: true")
        outputContains("Build inside a test executor uses Native services: true")
    }

    def "daemon with different native services flag is not reused"() {
        given:
        executer.requireDaemon()
        executer.requireIsolatedDaemons()

        when:

    }

    def "stopping the queue stops the underlying executor"() {
        ExecutorFactory factory = Mock(ExecutorFactory)
        ManagedExecutor executor = Mock(ManagedExecutor)

        when:
        queue = new DefaultConditionalExecutionQueue(DISPLAY_NAME, workerLimits, factory, workerLeaseService)

        then:
        1 * factory.create(_) >> executor

        when:
        queue.stop()

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

        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:

    final BlockTarget waitFor = new BlockTarget(instant)

    public final TestExecutor executor = new TestExecutor(logger)
    public final TestExecutorFactory executorFactory = new TestExecutorFactory(executor)

    def setup() {
        instant.mainThread(Thread.currentThread())
    }

    def cleanup() {
        try {
            executor.stop(new Date(System.currentTimeMillis() + 5000))
        } finally {