@Timeout(30)
@Tag("Slowish")
class ConnectionReuseTest {
  @RegisterExtension
  val platform: PlatformRule = PlatformRule()

  @RegisterExtension
  val clientTestRule: OkHttpClientTestRule = OkHttpClientTestRule()

  @StartStop
  private val server = MockWebServer()

  private val handshakeCertificates = platform.localhostHandshakeCertificates()

   * represent the length.
   */
  internal const val B1_MASK_LENGTH = 127

  internal const val OPCODE_CONTINUATION = 0x0
  internal const val OPCODE_TEXT = 0x1
  internal const val OPCODE_BINARY = 0x2

  internal const val OPCODE_CONTROL_CLOSE = 0x8
  internal const val OPCODE_CONTROL_PING = 0x9
  internal const val OPCODE_CONTROL_PONG = 0xa

  /**

@Tag("Slow")
class WholeOperationTimeoutTest {
  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()
  private val client = clientTestRule.newClient()

  @StartStop
  private val server = MockWebServer()

  @Test
  fun defaultConfigIsNoTimeout() {
    val request =
      Request
        .Builder()
        .url(server.url("/"))
        .build()
    val call = client.newCall(request)

      request: RecordedRequest,
      response: MockResponse,
    ) {
      val settings = response.settings
      stream.connection.setSettings(settings)

      val bodyDelayNanos = response.bodyDelayNanos
      val trailers = response.trailers
      val body = response.body
      val socketHandler = response.socketHandler
      val outFinished = (
        body == null &&
          response.pushPromises.isEmpty() &&

  }

  companion object {
    private const val CONNECTION = "connection"
    private const val HOST = "host"
    private const val KEEP_ALIVE = "keep-alive"
    private const val PROXY_CONNECTION = "proxy-connection"
    private const val TRANSFER_ENCODING = "transfer-encoding"
    private const val TE = "te"
    private const val ENCODING = "encoding"
    private const val UPGRADE = "upgrade"

  }

  private class Entry {
    private val url: HttpUrl
    private val varyHeaders: Headers
    private val requestMethod: String
    private val protocol: Protocol
    private val code: Int
    private val message: String
    private val responseHeaders: Headers
    private val handshake: Handshake?
    private val sentRequestMillis: Long
    private val receivedResponseMillis: Long

    /**

      )
  }

  @Test
  fun chainMaxLength() {
    val heldCertificates = chainOfLength(10)
    val certificates: MutableList<Certificate> = ArrayList()
    for (heldCertificate in heldCertificates) {
      certificates.add(heldCertificate.certificate)
    }
    val root = heldCertificates[heldCertificates.size - 1].certificate
    val cleaner = get(root)

    override val timestampNs: Long,
    override val call: Call,
    val domainName: String,
    val inetAddressList: List<InetAddress>,
  ) : CallEvent() {
    override fun closes(event: CallEvent): Boolean = event is DnsStart && call == event.call && domainName == event.domainName
  }

  data class ConnectStart(
    override val timestampNs: Long,
    override val call: Call,
    val inetSocketAddress: InetSocketAddress,
    val proxy: Proxy?,

    server.enqueue(MockResponse())
    dns["san.com"] = Dns.SYSTEM.lookup(server.hostName).subList(0, 1)
    val sanUrl = url.newBuilder().host("san.com").build()
    val latch1 = CountDownLatch(1)
    val latch2 = CountDownLatch(1)
    val latch3 = CountDownLatch(1)
    val latch4 = CountDownLatch(1)
    val listener1: EventListener =
      object : EventListener() {
        override fun connectStart(
          call: Call,

  internal data class Message(
    val bytes: ByteString? = null,
    val string: String? = null,
  )

  internal data class Ping(
    val payload: ByteString,
  )

  internal data class Pong(
    val payload: ByteString,
  )

  internal data class Closing(
    val code: Int,
    val reason: String,
  )

  internal data class Closed(
    val code: Int,
    val reason: String,
  )