ListenableFuture<? extends V> input,
      Class<X> exceptionType,
      Function<? super X, ? extends V> fallback,
      Executor executor) {
    CatchingFuture<V, X> future = new CatchingFuture<>(input, exceptionType, fallback);
    input.addListener(future, rejectionPropagatingExecutor(executor, future));
    return future;
  }

  static <X extends Throwable, V extends @Nullable Object> ListenableFuture<V> create(

    private String processOutput;
    private InputStream processStdOutput;

    @Override
    public void connectStreams(Process process, String processName, Executor executor) {
        processStdOutput = process.getInputStream();
    }

    @Override
    @SuppressWarnings("DefaultCharset")
    public void start() {
        if (processStdOutput == null) {

        this.executer = executer
        this.testDir = testDir
    }

    String initScriptContent() {
    }

    void afterBuild() {
    }

    Statement apply(Statement base, FrameworkMethod method, Object target) {
        def temporaryFolder = testDir.testDirectory
        def initFile = temporaryFolder.file(this.getClass().getSimpleName() + "-init.gradle")

import org.gradle.integtests.fixtures.executer.AbstractGradleExecuter
import org.gradle.integtests.fixtures.executer.ExecutionFailure
import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.integtests.fixtures.executer.GradleContextualExecuter
import org.gradle.integtests.fixtures.executer.GradleDistribution
import org.gradle.integtests.fixtures.executer.GradleExecuter

    def "does not configure build when action does not query any models"() {
        setupBuild()

        when:
        def model = withConnection {
            def executer = action(new NoOpAction())
            collectOutputs(executer)
            executer.run()
        }

        then:
        model == "result"

        and:
        assertHasConfigureSuccessfulLogging()
        result.assertNotOutput(prefix)
    }

        when:
        GradleExecuter executer = prepareWrapperExecuter(current, previous).withWarningMode(null)

        then:
        checkWrapperWorksWith(executer, previous)

        cleanup:
        cleanupDaemons(executer, previous)
    }

    void checkWrapperWorksWith(GradleExecuter executer, GradleDistribution executionVersion) {
        def result = executer.usingExecutable('gradlew').withTasks('hello').run()

        executer.withArguments(
            "wrapper",
            "--gradle-distribution-url",
            distributionUri.toString(),
        )
        keyStore.trustStoreArguments.each {
            executer.withArgument(it)
        }
        executer.run()
    }

    GradleExecuter getWrapperExecuter() {
        executer.requireOwnGradleUserHomeDir()
        executer.requireIsolatedDaemons()
        executer.beforeExecute {

O servidor de desenvolvimento escutará no endereço de IP `127.0.0.1` por padrão, este é o IP que sua máquina usa para se comunicar com ela mesma (`localhost`).

## `fastapi run`

Quando você rodar `fastapi run`, isso executará em modo de produção por padrão.

Este modo terá **recarregamento automático desativado** por padrão.

    private class NonBlockingActor implements Actor {
        private final Dispatch<MethodInvocation> dispatch;
        private final ManagedExecutor executor;
        private final ExceptionTrackingFailureHandler failureHandler;

        public NonBlockingActor(Object targetObject) {
            executor = executorFactory.create("Dispatch " + targetObject);

        """

        when:
        run("installDist")

        def out = new ByteArrayOutputStream()
        def executer = new ScriptExecuter()
        executer.workingDir = testDirectory
        executer.standardOutput = out
        executer.commandLine = "build/install/test/bin/test"
        def result = executer.run()
        then:
        result.assertNormalExitValue()