.url("https://en.wikipedia.org/w/index.php")
        .post(formBody)
        .build();

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

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

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

/**
 * Utility class for handling response data.
 */
public final class ResponseDataUtil {

    /**
     * Private constructor to prevent instantiation of this utility class.
     */
    private ResponseDataUtil() {
    }

    /**
     * Creates a temporary file containing the response body from the given ResponseData.
     *
     * @param responseData the response data containing the response body

  }

  @Test @Disabled
  fun response() {
    val response: Response = Response.Builder().build()
    val request: Request = response.request()
    val protocol: Protocol = response.protocol()
    val code: Int = response.code()
    val message: String = response.message()
    val handshake: Handshake? = response.handshake()
    val headers: Headers = response.headers()
    val body: ResponseBody = response.body()

        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          response.use {
            if (!response.isSuccessful) throw IOException("Unexpected code $response")

            for ((name, value) in response.headers) {
              println("$name: $value")
            }

            println(response.body.string())
          }
        }
      },
    )
  }
}

 * Extends the common request interface with type-safe response handling,
 * allowing requests to specify their expected response type.
 *
 * @author mbechler
 * @param <T> response type
 */
public interface Request<T extends CommonServerMessageBlockResponse> extends CommonServerMessageBlockRequest {

    /**
     * Initializes and returns a response object for this request.
     *
     * @param tc the CIFS context

    webSocket = slackApi.rtm(rtmStartResponse.url, this);
  }

  // TODO(jwilson): can I read the response body? Do I have to?
  //                the body from slack is a 0-byte-buffer
  @Override public synchronized void onOpen(WebSocket webSocket, Response response) {
    System.out.println("onOpen: " + response);
  }

  // TOOD(jwilson): decode incoming messages and dispatch them somewhere.

        .url(url)
        .build();
    try (Response response = client.newCall(request).execute()) {
      String responseSource = response.networkResponse() != null ? ("(network: "
          + response.networkResponse().code()
          + " over "
          + response.protocol()
          + ")") : "(cache)";
      int responseCode = response.code();

  }

  @Test
  fun response() {
    val response: Response = Response.Builder().build()
    val request: Request = response.request
    val protocol: Protocol = response.protocol
    val code: Int = response.code
    val successful: Boolean = response.isSuccessful
    val message: String = response.message
    val handshake: Handshake? = response.handshake

        SecDispatcher.ValidationResponse response = secDispatcher.validateConfiguration();
        if (!response.isValid() || context.options().verbose().orElse(false)) {
            dumpResponse(context, "", response);
        }
        return response.isValid();
    }

    protected void dumpResponse(EncryptContext context, String indent, SecDispatcher.ValidationResponse response) {
        context.logger.info(messageBuilderFactory

    )
    val call = client.newCall(Request.Builder().url(server.url("/")).build())
    val response = call.execute()
    assertThat(response.handshake!!.peerPrincipal)
      .isEqualTo(X500Principal("CN=Local Host"))
    assertThat(response.handshake!!.localPrincipal)
      .isEqualTo(X500Principal("CN=Jethro Willis"))
    assertThat(response.body.string()).isEqualTo("abc")
  }

  @Test
  fun clientAuthForNeeds() {