Symmetrically, interceptors can rewrite response headers and transform the response body. This is generally more dangerous than rewriting request headers because it may violate the webserver's expectations!

If you're in a tricky situation and prepared to deal with the consequences, rewriting response headers is a powerful way to work around problems. For example, you can fix a server's misconfigured `Cache-Control` response header to enable better response caching:

  }

  @Test
  fun headers() {
    var headers: Headers = headersOf("", "")
    headers = mapOf("" to "").toHeaders()
    val get: String? = headers[""]
    val date: Date? = headers.getDate("")
    val instant: Instant? = headers.getInstant("")
    val size: Int = headers.size
    val name: String = headers.name(0)
    val value: String = headers.value(0)
    val names: Set<String> = headers.names()

    )

    val call = client.newCall(Request(server.url("/")))
    call.execute().use { response ->
      assertThat(response.headers["Content-Length"]).isNull()
      assertThat(response.body.source().readUtf8()).isEqualTo("Hello")
      assertThat(response.trailers()).isEqualTo(Headers.EMPTY)
    }
  }

  @Test
  fun cancelWhileReadingTrailersHttp1() {
    cancelWhileReadingTrailers(Protocol.HTTP_1_1)
  }

When writing request headers, use `header(name, value)` to set the only occurrence of `name` to `value`. If there are existing values, they will be removed before the new value is added. Use `addHeader(name, value)` to add a header without removing the headers already present.

    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)

import java.io.IOException;
import java.io.Reader;
import java.util.Iterator;
import org.jspecify.annotations.Nullable;

/**
 * A {@link Reader} that concatenates multiple readers.
 *
 * @author Bin Zhu
 * @since 1.0
 */
@J2ktIncompatible
@GwtIncompatible
final class MultiReader extends Reader {
  private final Iterator<? extends CharSource> it;
  private @Nullable Reader current;

      Request
        .Builder()
        .url(server.url("/"))
        .header("", "A")
        .build()
    }
  }

  @Test
  fun emptyResponseHeaderNameIsLenient() {
    val headers = Headers.Builder()
    addHeaderLenient(headers, ":A")
    server.enqueue(
      MockResponse(
        headers = headers.build(),
        body = "body",
      ),
    )

        if (headers != null) {
            headers.forEach(header -> callback.accept(header.getFirst(), header.getSecond()));
        }
    }

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(

    assertThat(connect.headers["Proxy-Connection"]).isEqualTo("Keep-Alive")
    assertThat(connect.headers["Host"]).isEqualTo("android.com:443")
    val get = server.takeRequest()
    assertThat(get.headers["Private"]).isEqualTo("Secret")
    assertThat(get.headers["User-Agent"]).isEqualTo("App 1.0")
    assertThat(hostnameVerifier.calls).containsExactly("verify android.com")
  }

  /**