value: String,
    ) = apply {
      headers.add(name, value)
    }

    /** Removes all headers named [name] on this builder. */
    open fun removeHeader(name: String) =
      apply {
        headers.removeAll(name)
      }

    /** Removes all headers on this builder and adds [headers]. */
    open fun headers(headers: Headers) =
      apply {
        this.headers = headers.newBuilder()
      }

  internal constructor(
    requestLine: String,
    headers: Headers,
    chunkSizes: List<Int>,
    bodySize: Long,
    body: Buffer,
    sequenceNumber: Int,
    failure: IOException?,
    method: String?,
    path: String?,
    handshake: Handshake?,
    requestUrl: HttpUrl?,
  ) {
    this.requestLine = requestLine
    this.headers = headers
    this.chunkSizes = chunkSizes
    this.bodySize = bodySize

        return read(reader, null);
    }

    /**
     * Reads an XML node from a reader.
     */
    @Nonnull
    public static XmlNode read(Reader reader, @Nullable InputLocationBuilder locationBuilder)
            throws XMLStreamException {
        return getService().doRead(reader, locationBuilder);
    }

    /**
     * Reads an XML node from an XMLStreamReader.
     */

        CurlResponse response = new CurlResponse();
        Map<String, List<String>> headers = new HashMap<>();
        headers.put("Content-Type", Arrays.asList("application/json"));
        headers.put("CONTENT-LENGTH", Arrays.asList("100"));
        headers.put("accept-encoding", Arrays.asList("gzip"));
        response.setHeaders(headers);

        // All header access should be case-insensitive

import java.util.Date
import okhttp3.Headers.Companion.headersOf
import org.junit.jupiter.api.Test

class HeadersKotlinTest {
  @Test fun getOperator() {
    val headers = headersOf("a", "b", "c", "d")
    assertThat(headers["a"]).isEqualTo("b")
    assertThat(headers["c"]).isEqualTo("d")
    assertThat(headers["e"]).isNull()
  }

  @Test fun iteratorOperator() {
    val headers = headersOf("a", "b", "c", "d")

 * limitations under the License.
 */
package okhttp3.mockwebserver

import okhttp3.Headers

class PushPromise(
  @get:JvmName("method") val method: String,
  @get:JvmName("path") val path: String,
  @get:JvmName("headers") val headers: Headers,
  @get:JvmName("response") val response: MockResponse,
) {
  @JvmName("-deprecated_method")
  @Deprecated(
    message = "moved to val",

    val localPrincipal: Principal? = handshake.localPrincipal()
  }

  @Test @Disabled
  fun headers() {
    var headers: Headers = Headers.of("", "")
    headers = Headers.of(mapOf("" to ""))
    val size: Int = headers.size()
  }

  @Test @Disabled
  fun httpLoggingInterceptor() {
    val interceptor = HttpLoggingInterceptor()

     */
    public static String readText(final Reader reader) {
        assertArgumentNotNull("reader", reader);

        final StringBuilder buf = new StringBuilder(BUF_SIZE);
        CopyUtil.copy(reader, buf);
        return new String(buf);
    }

      override fun matches(header: DerHeader): Boolean = true

      override fun fromDer(reader: DerReader): AnyValue {
        reader.read("ANY") { header ->
          val bytes = reader.readUnknown()
          return AnyValue(
            tagClass = header.tagClass,
            tag = header.tag,
            constructed = header.constructed,
            length = header.length,
            bytes = bytes,

    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)