}

  @Test fun ofRejectsNullChar() {
    assertFailsWith<IllegalArgumentException> {
      headersOf("User-Agent", "Square\u0000OkHttp")
    }
  }

  @Test fun ofMapThrowsOnEmptyName() {
    assertFailsWith<IllegalArgumentException> {
      mapOf("" to "OkHttp").toHeaders()
    }
  }

  @Test fun ofMapThrowsOnBlankName() {
    assertFailsWith<IllegalArgumentException> {
      mapOf(" " to "OkHttp").toHeaders()

    val bytes = "170d3139313231362333303231305a".decodeHex()
    assertFailsWith<ProtocolException> {
      Adapters.UTC_TIME.fromDer(bytes)
    }.also { expected ->
      assertThat(expected).hasMessage("Failed to parse UTCTime 191216#30210Z")
    }
  }

  @Test fun `cannot decode generalized time with offset`() {
    assertFailsWith<ProtocolException> {

    builder.networkInterceptors().addAll(listOf(null) as List<Interceptor>)
    assertFailsWith<IllegalStateException> {
      builder.build()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Null network interceptor: [null]")
    }
  }

  @Test fun testH2PriorKnowledgeOkHttpClientConstructionFallback() {
    assertFailsWith<IllegalArgumentException> {
      OkHttpClient.Builder()

  }

  @Test fun closeCodeOutOfRangeThrows() {
    assertFailsWith<IllegalArgumentException> {
      clientWriter.writeClose(98724976, "Hello".encodeUtf8())
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Code must be in range [1000,5000): 98724976")
    }
  }

  @Test fun closeReservedThrows() {
    assertFailsWith<IllegalArgumentException> {

  }

  @Test
  fun requestHeaderValidationIsStrict() {
    assertFailsWith<IllegalArgumentException> {
      Request.Builder()
        .addHeader("a\tb", "Value")
    }
    assertFailsWith<IllegalArgumentException> {
      Request.Builder()
        .addHeader("Name", "c\u007fd")
    }
    assertFailsWith<IllegalArgumentException> {
      Request.Builder()
        .addHeader("", "Value")

        boundary = "simple boundary",
        source = Buffer().writeUtf8(multipart),
      )

    val part = parts.nextPart()!!
    assertFailsWith<EOFException> {
      assertThat(part.body.readUtf8()).isEqualTo("abcd\r\nefgh\r\n")
    }

    assertFailsWith<EOFException> {
      assertThat(parts.nextPart()).isNull()
    }
  }

  @Test fun `malformed headers`() {
    val multipart =
      """

        .build()

    // Should be pinned:
    assertFailsWith<SSLPeerUnverifiedException> {
      certificatePinner.check("example.co.uk", listOf(certB1.certificate))
    }
    assertFailsWith<SSLPeerUnverifiedException> {
      certificatePinner.check("foo.example.co.uk", listOf(certB1.certificate))
    }
    assertFailsWith<SSLPeerUnverifiedException> {

import assertk.assertions.isTrue
import java.io.IOException
import java.io.InputStreamReader
import java.io.Reader
import java.nio.charset.StandardCharsets
import java.util.concurrent.atomic.AtomicBoolean
import kotlin.test.assertFailsWith
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.ResponseBody.Companion.toResponseBody
import okhttp3.internal.and
import okio.Buffer
import okio.BufferedSource
import okio.ByteString

    data.write("0a00".decodeHex()) // Empty pong.
    assertFailsWith<ProtocolException> {
      clientReader.processNextFrame()
    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("Control frames must be final.")
    }
  }

  @Test fun reservedFlag1IsUnsupportedWithNoCompression() {
    data.write("ca00".decodeHex()) // Empty pong, flag 1 set.
    assertFailsWith<ProtocolException> {

      )

    call.execute().use { response ->
      assertThat(response.body.string()).isEqualTo("abc")
      val requestBodyOut = requestBody.takeSink()
      assertFailsWith<IOException> {
        SlowRequestBody.writeTo(requestBodyOut)
      }
      assertFailsWith<IOException> {
        requestBodyOut.close()
      }
    }

    // Confirm that the connection pool was not corrupted by making another call.