.build();

    Call call = client.newCall(new Request.Builder()
        .url(server.url("/"))
        .build());
    Response response = call.execute();
    System.out.println(response.handshake().tlsVersion());
  }

  public static void main(String... args) throws Exception {
    new HttpsServer().run();
  }

        this.unprefixedPathKeys = unprefixedPathKeys;
        this.projectDir = projectDir;
        this.pathTranslator = pathTranslator;
    }

    @Override
    public Object execute(String expression, Object value) {
        expression = ValueSourceUtils.trimPrefix(expression, expressionPrefixes, true);

        if (projectDir != null && value != null && unprefixedPathKeys.contains(expression)) {

execute-api.eu-west-1.amazonaws.com
execute-api.eu-west-2.amazonaws.com
execute-api.eu-west-3.amazonaws.com
execute-api.il-central-1.amazonaws.com
execute-api.me-central-1.amazonaws.com
execute-api.me-south-1.amazonaws.com
execute-api.sa-east-1.amazonaws.com
execute-api.us-east-1.amazonaws.com
execute-api.us-east-2.amazonaws.com
execute-api.us-gov-east-1.amazonaws.com
execute-api.us-gov-west-1.amazonaws.com

import okhttp3.Connection
import okhttp3.Route
import okio.IOException

/**
 * Listener for connection events. Extend this class to monitor the new connections and closes.
 *
 * All event methods must execute fast, without external locking, cannot throw exceptions,
 * attempt to mutate the event parameters, or be reentrant back into the client.
 * Any IO - writing to files or network should be done asynchronously.
 */

    val client = HttpAsyncClients.createHttp2Default()

    client.use { client ->
      client.start()
      val request = SimpleHttpRequests.get("https://google.com/robots.txt")
      val response = client.execute(request, LoggingCallback).get()

      println("Protocol ${response.version}")
      println("Response ${response.code}")
      println("${response.body.bodyText.substring(0, 20)}...")

    val request =
      Request
        .Builder()
        .url("https://sni.cloudflaressl.com/cdn-cgi/trace")
        .header("Host", "cloudflare-dns.com")
        .build()
    client.newCall(request).execute().use { response ->
      assertThat(response.code).isEqualTo(200)
      assertThat(response.protocol).isEqualTo(Protocol.HTTP_2)

      assertThat(response.body.string()).contains("h=cloudflare-dns.com")
    }
  }

    return new TrustedListenableFutureTask<>(callable);
  }

  /**
   * Creates a {@code ListenableFutureTask} that will upon running, execute the given {@code
   * Runnable}, and arrange that {@code get} will return the given result on successful completion.
   *
   * @param runnable the runnable task

import org.codelibs.fess.mylasta.direction.FessConfig;
import org.codelibs.fess.util.ComponentUtil;
import org.codelibs.fess.util.RenderDataUtil;
import org.lastaflute.core.direction.ObjectiveConfig;
import org.lastaflute.web.Execute;
import org.lastaflute.web.response.HtmlResponse;
import org.lastaflute.web.response.render.RenderData;
import org.lastaflute.web.ruts.process.ActionRuntime;

import jakarta.annotation.Resource;

/**

    val refusedConnection = url.openConnection() as HttpURLConnection
    assertFailsWith<ConnectException> {
      refusedConnection.getResponseCode()
    }.also { expected ->
      assertThat(expected.message!!).contains("refused")
    }
  }

  @Test
  fun http100Continue() {
    server.enqueue(MockResponse().setBody("response"))
    val url = server.url("/").toUrl()

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("https://publicobject.com/secrets/hellosecret.txt")
        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      System.out.println(response.body().string());
    }
  }