.build(),
    )
    val url = server.url("/")
    assertThat(get(url).body.string()).isEqualTo("A")
    val request =
      Request.Builder()
        .url(url)
        .method("POST", requestBodyOrNull("POST"))
        .build()
    val invalidate = client.newCall(request).execute()
    assertThat(invalidate.body.string()).isEqualTo("B")
    assertThat(get(url).body.string()).isEqualTo("C")
  }

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public class GetExample {
  final OkHttpClient client = new OkHttpClient();

  String run(String url) throws IOException {
    Request request = new Request.Builder()
        .url(url)
        .build();

    try (Response response = client.newCall(request).execute()) {
      return response.body().string();
    }
  }

  override fun isCanceled(): Boolean = false

  override fun candidateConnection(): RealConnection? = null

  override fun proxySelectStart(url: HttpUrl) {
  }

  override fun proxySelectEnd(
    url: HttpUrl,
    proxies: List<Proxy>,
  ) {
  }

  override fun dnsStart(socketHost: String) {
  }

  override fun dnsEnd(
    socketHost: String,

    }
    return result
  }

fun Response.commonClose() {
  body.close()
}

fun Response.commonToString(): String = "Response{protocol=$protocol, code=$code, message=$message, url=${request.url}}"

fun Response.Builder.commonRequest(request: Request) =
  apply {
    this.request = request
  }

fun Response.Builder.commonProtocol(protocol: Protocol) =
  apply {

      .addNetworkInterceptor(CHECK_HANDSHAKE_INTERCEPTOR)
      .build();

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

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

  }

  public static void main(String... args) throws Exception {
    OkHttpClient client = new OkHttpClient();

    // Create request for remote resource.
    Request request = new Request.Builder()
        .url(ENDPOINT)
        .build();

    // Execute the request and retrieve the response.
    try (Response response = client.newCall(request).execute()) {
      // Deserialize HTTP response to concrete type.

	public fun tag (Ljava/lang/Object;)Lokhttp3/Request$Builder;
	public final fun tag (Lkotlin/reflect/KClass;Ljava/lang/Object;)Lokhttp3/Request$Builder;
	public fun url (Ljava/lang/String;)Lokhttp3/Request$Builder;
	public fun url (Ljava/net/URL;)Lokhttp3/Request$Builder;
	public fun url (Lokhttp3/HttpUrl;)Lokhttp3/Request$Builder;
}

public abstract class okhttp3/RequestBody {

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  private var client = clientTestRule.newClientBuilder().build()

  private lateinit var server: MockWebServer

  val request by lazy { Request(server.url("/")) }

  @BeforeEach
  fun setup(server: MockWebServer) {
    this.server = server
  }

  @Test
  fun suspendCall() {
    runTest {
      server.enqueue(MockResponse(body = "abc"))

    val address = InetSocketAddress(_inetSocketAddress!!.address.hostName, port)
    return Proxy(Proxy.Type.HTTP, address)
  }

  /**
   * Returns a URL for connecting to this server.
   *
   * @param path the request path, such as "/".
   */
  fun url(path: String): HttpUrl {
    return HttpUrl.Builder()
      .scheme(if (sslSocketFactory != null) "https" else "http")
      .host(hostName)
      .port(port)

  }

  @Test fun nullDefaultProxySelector() {
    server!!.enqueue(MockResponse(body = "abc"))
    ProxySelector.setDefault(null)
    val client = clientTestRule.newClient()
    val request = Request(server!!.url("/"))
    val response = client.newCall(request).execute()
    assertThat(response.body.string()).isEqualTo("abc")
  }

  @Test fun sslSocketFactorySetAsSocketFactory() {
    val builder = OkHttpClient.Builder()