.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

          "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(

import mockwebserver3.internal.DEFAULT_REQUEST_LINE_HTTP_1
import mockwebserver3.internal.DEFAULT_REQUEST_LINE_HTTP_2
import mockwebserver3.internal.MockWebServerSocket
import mockwebserver3.internal.RecordedRequest
import mockwebserver3.internal.RequestLine
import mockwebserver3.internal.ThrottledSink
import mockwebserver3.internal.TriggerSink
import mockwebserver3.internal.decodeRequestLine
import okhttp3.Headers

  fun ipv6() {
    val recordedRequest = requestToHostnameViaProxy("2607:f8b0:400b:804::200e")
    assertThat(recordedRequest.url.host).isEqualTo("2607:f8b0:400b:804::200e")
    assertThat(recordedRequest.handshakeServerNames).isEmpty()
  }

  /** No SNI for literal IPv4 addresses. */
  @Test
  fun ipv4() {
    val recordedRequest = requestToHostnameViaProxy("76.223.91.57")

    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

import java.io.IOException
import java.net.Inet6Address
import java.net.ProtocolException
import mockwebserver3.RecordedRequest
import okhttp3.Headers
import okhttp3.HttpUrl
import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
import okio.ByteString

internal fun RecordedRequest(
  requestLine: RequestLine,
  headers: Headers,
  chunkSizes: List<Int>?,
  bodySize: Long,

    .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.

  mockwebserver3.PushPromise(
    method = method,
    path = path,
    headers = headers,
    response = response.wrap(),
  )

internal fun mockwebserver3.RecordedRequest.unwrap(): RecordedRequest =
  RecordedRequest(
    requestLine = requestLine,
    headers = headers,
    chunkSizes = chunkSizes ?: listOf(),
    bodySize = bodySize,
    body = Buffer().write(body ?: ByteString.EMPTY),

  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();

class CustomDispatcherTest {
  @StartStop private val mockWebServer = MockWebServer()

  @Test
  fun simpleDispatch() {
    val requestsMade = mutableListOf<RecordedRequest>()
    val dispatcher: Dispatcher =
      object : Dispatcher() {
        override fun dispatch(request: RecordedRequest): MockResponse {
          requestsMade.add(request)
          return MockResponse()
        }
      }
    assertThat(requestsMade.size).isEqualTo(0)