}

  @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> {

      )

    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.

  }

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

import assertk.assertThat
import assertk.assertions.isEmpty
import assertk.assertions.isEqualTo
import assertk.assertions.isNotNull
import assertk.assertions.isNull
import javax.net.ssl.SSLException
import kotlin.test.assertFailsWith
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import okhttp3.testing.PlatformRule
import okhttp3.tls.HandshakeCertificates
import okhttp3.tls.HeldCertificate

package okhttp3.dnsoverhttps

import assertk.assertThat
import assertk.assertions.containsExactly
import assertk.assertions.isEqualTo
import java.net.InetAddress
import java.net.UnknownHostException
import kotlin.test.assertFailsWith
import okhttp3.AsyncDns.Companion.TYPE_A
import okhttp3.AsyncDns.Companion.TYPE_AAAA
import okhttp3.dnsoverhttps.DnsRecordCodec.decodeAnswers
import okio.ByteString.Companion.decodeHex
import org.junit.jupiter.api.Test

  }

  @Test fun addThrowsOnEmptyName() {
    assertFailsWith<IllegalArgumentException> {
      Headers.Builder().add(": bar")
    }
    assertFailsWith<IllegalArgumentException> {
      Headers.Builder().add(" : bar")
    }
  }

  @Test fun addThrowsOnNoColon() {
    assertFailsWith<IllegalArgumentException> {
      Headers.Builder().add("foo bar")
    }
  }

      )
    val buffer = Buffer()
    assertFailsWith<IndexOutOfBoundsException> {
      operator.read(0, buffer, -1L)
    }
  }

  @Test
  fun writeBounds() {
    val operator =
      FileOperator(
        randomAccessFile!!.getChannel(),
      )
    val buffer = Buffer().writeUtf8("abc")
    assertFailsWith<IndexOutOfBoundsException> {
      operator.write(0, buffer, -1L)
    }

import assertk.assertions.hasMessage
import assertk.assertions.isEmpty
import assertk.assertions.isEqualTo
import assertk.assertions.isNull
import java.io.IOException
import java.security.cert.Certificate
import kotlin.test.assertFailsWith
import okhttp3.Handshake.Companion.handshake
import okhttp3.tls.HeldCertificate
import org.junit.jupiter.api.Test

class HandshakeTest {
  val serverRoot =
    HeldCertificate.Builder()

import assertk.fail
import java.io.IOException
import java.net.ServerSocket
import java.net.Socket
import java.net.SocketException
import java.util.concurrent.TimeUnit
import kotlin.test.assertFailsWith
import okhttp3.DelegatingServerSocketFactory
import okhttp3.DelegatingSocketFactory
import okhttp3.OkHttpClient
import okhttp3.OkHttpClientTestRule
import okhttp3.Request
import okhttp3.RequestBody

import assertk.assertThat
import assertk.assertions.isEqualTo
import assertk.assertions.isFalse
import assertk.assertions.isSameAs
import assertk.assertions.isTrue
import java.util.concurrent.TimeUnit
import kotlin.test.assertFailsWith
import okhttp3.CacheControl.Companion.parse
import okhttp3.Headers.Companion.headersOf
import org.junit.jupiter.api.Test

class CacheControlJvmTest {
  @Test
  @Throws(Exception::class)