.build()
    client.newCall(request).execute()
    val recordedRequest = server.takeRequest()
    assertThat(recordedRequest.body?.utf8()).isEqualTo("ABC")
    assertThat(recordedRequest.headers["Original-Header"]).isEqualTo("foo")
    assertThat(recordedRequest.headers["OkHttp-Intercepted"]).isEqualTo("yep")
    assertThat(recordedRequest.method).isEqualTo("POST")
  }

  @Test

    response.body.close()
    val recordedRequest1 = server.takeRequest()
    assertThat(recordedRequest1.method).isEqualTo("POST")
    assertThat(recordedRequest1.body?.utf8()).isEqualTo(body)
    assertThat(recordedRequest1.headers["Authorization"]).isNull()
    val recordedRequest2 = server.takeRequest()
    assertThat(recordedRequest2.method).isEqualTo("POST")
    assertThat(recordedRequest2.body?.utf8()).isEqualTo(body)

    var headers: Headers = recordedRequest.headers
    val header: String? = recordedRequest.getHeader("")
    var chunkSizes: List<Int>? = recordedRequest.chunkSizes
    var bodySize: Long = recordedRequest.bodySize
    var body: Buffer = recordedRequest.body
    var utf8Body: String = recordedRequest.body.readUtf8()
    var sequenceNumber: Int = recordedRequest.sequenceNumber

          "0003b00049df00112",
      ),
    )
    val result = dns.lookup("google.com")
    assertThat(result).isEqualTo(listOf(address("157.240.1.18")))
    val recordedRequest = server.takeRequest()
    assertThat(recordedRequest.method).isEqualTo("GET")
    assertThat(recordedRequest.url.encodedQuery)
      .isEqualTo("ct&dns=AAABAAABAAAAAAAABmdvb2dsZQNjb20AAAEAAQ")
  }

  @Test
  fun getIpv6() {
    server.enqueue(
      dnsResponse(

    .url(server.url("/"))
    .build());
Response response = call.execute();
System.out.println(response.handshake().peerPrincipal());
RecordedRequest recordedRequest = server.takeRequest();
System.out.println(recordedRequest.getHandshake().peerPrincipal());
```

This handshake is successful because each party has prearranged to trust the root certificate that
signs the other party's chain.

    these accessors will throw an `IllegalStateException` if the service has not yet been started.

 *  Breaking: Rename `RecordedRequest.path` to `RecordedRequest.target`. (This property is
    _sometimes_ a path, but it can also be a path and query, or a full URL.)

 *  Breaking: Decompose the `RecordedRequest.requestLine` into three properties, `method`, `target`,

  RecordedRequest request1 = server.takeRequest();
  assertEquals("/v1/chat/messages/", request1.getUrl().encodedPath());
  assertNotNull(request1.getHeaders().get("Authorization"));

  RecordedRequest request2 = server.takeRequest();
  assertEquals("/v1/chat/messages/2", request2.getUrl().encodedPath());

  RecordedRequest request3 = server.takeRequest();

import java.util.concurrent.atomic.AtomicInteger
import kotlin.test.assertFailsWith
import mockwebserver3.Dispatcher
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.RecordedRequest
import mockwebserver3.SocketEffect.CloseSocket
import mockwebserver3.SocketEffect.Stall
import mockwebserver3.junit5.StartStop
import okhttp3.EventRecorder
import okhttp3.Interceptor
import okhttp3.OkHttpClient

    server.enqueue(MockResponse())
    val call = client.newCall(Request(server.url("/")))
    val response = call.execute()
    assertThat(response.body.string()).isEqualTo("")
    val recordedRequest = server.takeRequest()
    assertThat(recordedRequest.headers[":authority"]).isEqualTo("privateobject.com")
  }

  private fun gzip(bytes: String): Buffer {
    val bytesOut = Buffer()
    val sink = GzipSink(bytesOut).buffer()

    val response1 = client.newCall(request1).execute()
    assertThat(response1.body.string()).isEqualTo("ABC")
    val recordedRequest1 = server.takeRequest()
    assertThat(recordedRequest1.requestLine).isEqualTo("GET /foo HTTP/1.1")
    assertThat(recordedRequest1.connectionIndex).isEqualTo(0)
    assertThat(recordedRequest1.exchangeIndex).isEqualTo(0)
    val request2 = Request.Builder().url(server.url("/bar")).build()