headers = Headers.headersOf("content-type", "application/json"),
      ),
    )
    server.enqueue(
      MockResponse(
        body =
          """
          |data: hey
          |
          |
          """.trimMargin(),
        headers = Headers.headersOf("content-type", "text/event-stream"),
      ),
    )

      MockResponse(
        code = 302,
        headers = headersOf("Location", "/b"),
      ),
    )
    server.enqueue(MockResponse())

    val request = Request(server.url("/"))
    val call = client.newCall(request)
    val response = call.execute()

    assertThat(response.request.url.encodedPath).isEqualTo("/b")
    assertThat(response.request.headers).isEqualTo(headersOf())
  }

import okhttp3.CallEvent.ResponseHeadersEnd
import okhttp3.CallEvent.ResponseHeadersStart
import okhttp3.CallEvent.SecureConnectEnd
import okhttp3.CallEvent.SecureConnectStart
import okhttp3.Headers.Companion.headersOf
import okhttp3.internal.duplex.AsyncRequestBody
import okhttp3.testing.PlatformRule
import okio.BufferedSink
import okio.IOException
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Disabled

import mockwebserver3.internal.decodeRequestLine
import okhttp3.Headers
import okhttp3.Headers.Companion.headersOf
import okio.Buffer
import okio.ByteString
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Timeout

@Timeout(30)
class RecordedRequestTest {
  private val headers: Headers = Headers.EMPTY

  @Test fun testIPv4() {
    val socket =
      MockWebServerSocket(

    val body = "hello".toRequestBody()
    val headers = headersOf("User-Agent", "RequestTest")
    val method = "PUT"
    val request =
      Request(
        url = url,
        headers = headers,
        method = method,
        body = body,
      )
    assertThat(request.url).isEqualTo(url)
    assertThat(request.headers).isEqualTo(headers)
    assertThat(request.method).isEqualTo(method)

    client.listener.assertTextMessage(message)
  }

  @Test
  fun messagesCompressedWhenConfigured() {
    val headers = headersOf("Sec-WebSocket-Extensions", "permessage-deflate")
    client.initWebSocket(random, responseHeaders = headers)
    server.initWebSocket(random, responseHeaders = headers)
    val message = repeat('a', RealWebSocket.DEFAULT_MINIMUM_DEFLATE_SIZE.toInt())
    server.webSocket!!.send(message)

      client
        .newBuilder()
        .cache(cache)
        .build()
    server.enqueue(
      MockResponse(
        headers = headersOf("cache-control", "max-age=60"),
        body = "ABCD",
      ),
    )
    server.enqueue(
      MockResponse(
        headers = headersOf("cache-control", "max-age=60"),
        body = "EFGH",
      ),
    )
    val call1 = client.newCall(Request(server.url("/")))

import okhttp3.CallEvent.ResponseBodyEnd
import okhttp3.CallEvent.ResponseBodyStart
import okhttp3.CallEvent.ResponseHeadersEnd
import okhttp3.CallEvent.ResponseHeadersStart
import okhttp3.EventRecorder
import okhttp3.Headers.Companion.headersOf
import okhttp3.OkHttpClientTestRule
import okhttp3.Protocol
import okhttp3.RecordingHostnameVerifier
import okhttp3.Request
import okhttp3.RequestBody
import okhttp3.RequestBody.Companion.toRequestBody

import java.util.concurrent.TimeUnit
import kotlin.test.assertFailsWith
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.junit5.StartStop
import okhttp3.Headers.Companion.headersOf
import okhttp3.internal.DoubleInetAddressDns
import okhttp3.internal.connection.RealConnectionPool.Companion.get
import okhttp3.testing.Flaky
import okhttp3.testing.PlatformRule

        .addHeader("h2", "v2")
        .trailers(headersOf("trailers", "boom"))
        .socketHandler(body)
        .build(),
    )
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )
    call.execute().use { response ->
      assertThat(response.headers)
        .isEqualTo(headersOf("h1", "v1", "h2", "v2"))