val socket = this.socket!!
    val source = this.source!!
    val sink = this.sink!!

    socket.soTimeout = 0
    noNewExchanges()
    return object : RealWebSocket.Streams(true, source, sink) {
      override fun close() {
        exchange.bodyComplete<IOException?>(-1L, responseDone = true, requestDone = true, e = null)
      }

      override fun cancel() {

      """Wildcard Assertion Failure: '$rule'
A wildcard rule was added that wildcards the first level! We'll need to change the ${PublicSuffixDatabase::class.java.name} to handle this."""
    }
  }

  companion object {
    private const val NEWLINE = '\n'.code
    private const val WILDCARD_CHAR = "*"
    private val EXCEPTION_RULE_MARKER: ByteString = "!".encodeUtf8()
  }
}

suspend fun main() {

      origin: String,
      protocol: ByteString,
      host: String,
      port: Int,
      maxAge: Long,
    ) {
      throw UnsupportedOperationException()
    }
  }

  companion object {
    private val logger = Logger.getLogger(MockHttp2Peer::class.java.name)
  }

  private val connectionPool: RealConnectionPool = client.connectionPool.delegate

  internal val eventListener: EventListener = client.eventListenerFactory.create(this)

  private val timeout =
    object : AsyncTimeout() {
      override fun timedOut() {
        ******@****.***()
      }
    }.apply {
      timeout(client.callTimeoutMillis.toLong(), MILLISECONDS)
    }

      settings: Settings,
    ) {}

    companion object {
      @JvmField
      val REFUSE_INCOMING_STREAMS: Listener =
        object : Listener() {
          @Throws(IOException::class)
          override fun onStream(stream: Http2Stream) {
            stream.close(REFUSED_STREAM, null)
          }
        }
    }
  }

  companion object {
    const val OKHTTP_CLIENT_WINDOW_SIZE = 16 * 1024 * 1024

 *  New: `ConnectionPool.setPolicy()` configures a minimum connection pool size for a target
    address. Use this to proactively open HTTP connections.

    Connections opened to fulfill this policy are subject to the connection pool's
    `keepAliveDuration` but do not count against the pool-wide `maxIdleConnections` limit.

    This feature increases the client's traffic and the load on the server. Talking to your server's

  @Test
  fun httpsWithIpAddress() {
    platform.assumeNotBouncyCastle()

    val localIpAddress = InetAddress.getLoopbackAddress().hostAddress

    // Create a certificate with an IP address in the subject alt name.
    val heldCertificate =
      HeldCertificate.Builder()
        .commonName("example.com")
        .addSubjectAlternativeName(localIpAddress!!)
        .build()
    val handshakeCertificates =

                sink.write(postBytes) // push bytes into the stream's buffer
                sink.flush() // Http2Connection.writeData subject to write window
                sink.close() // Http2Connection.writeData empty frame
              }
            },
        ),
      )
    val response = call.execute()
    assertThat(response.body.string()).isEqualTo("ABCDE")
    val request = server.takeRequest()

      if (outFinished) {
        this.sink.finished = true
        condition.signalAll() // Because doReadTimeout() may have changed.
      }
    }

    // Only DATA frames are subject to flow-control. Transmit the HEADER frame if the connection
    // flow-control window is fully depleted.
    if (!flushHeaders) {
      this.withLock {

   * corresponding response from the cache. Use this to evict selected responses.
   */
  @Throws(IOException::class)
  fun urls(): MutableIterator<String> {
    return object : MutableIterator<String> {
      private val delegate: MutableIterator<DiskLruCache.Snapshot> = cache.snapshots()
      private var nextUrl: String? = null
      private var canRemove = false