val stream = streams.remove(streamId)

      // The removed stream may be blocked on a connection-wide window update.
      condition.signalAll()

      return stream
    }
  }

  internal fun updateConnectionFlowControl(read: Long) {
    this.withLock {
      readBytes.update(total = read)
      val readBytesToAcknowledge = readBytes.unacknowledged

        )

      // Signature.
      val signature =
        Signature.getInstance(tbsCertificate.signatureAlgorithmName).run {
          initSign(issuerKeyPair.private)
          update(CertificateAdapters.tbsCertificate.toDer(tbsCertificate).toByteArray())
          sign().toByteString()
        }

      // Complete signed certificate.
      val certificate =
        Certificate(

    version we're testing against.

    ```kotlin
    implementation("org.conscrypt:conscrypt-openjdk-uber:2.0.0")
    ```

 *  New: Update the embedded public suffixes list.


## Version 3.13.1

_2019-02-05_

 *  Fix: Don't crash when using a custom `X509TrustManager` or `SSLSocket` on Android. When we

      abortQuietly(editor)
      return null
    }
  }

  @Throws(IOException::class)
  internal fun remove(request: Request) {
    cache.remove(key(request.url))
  }

  internal fun update(
    cached: Response,
    network: Response,
  ) {
    val entry = Entry(network)
    val snapshot = (cached.body as CacheResponseBody).snapshot
    var editor: DiskLruCache.Editor? = null
    try {

    other engines on other platforms. [Ktor] does this pretty well today!

 *  Breaking: Use `kotlin.time.Duration` in APIs like `OkHttpClient.Builder.callTimeout()`. This
    update also drops support for the `DurationUnit` functions introduced in earlier alpha releases
    of OkHttp 5.

 *  Breaking: Reorder the parameters in the Cache constructor that was introduced in 5.0.0-alpha.3.

    val response1 = call1.execute()
    waitForDataFrames(Http2Connection.OKHTTP_CLIENT_WINDOW_SIZE)

    // Cancel the call and close the response body. This should discard the buffered data and update
    // the connection flow-control window.
    call1.cancel()
    response1.close()
    val call2 = client.newCall(Request(server.url("/")))
    val response2 = call2.execute()

=== ":material-language-kotlin: Kotlin"
    ```kotlin
      private val client = OkHttpClient.Builder()

 * files to be deleted. The limit does not include filesystem overhead or the cache journal so
 * space-sensitive applications should set a conservative limit.
 *
 * Clients call [edit] to create or update the values of an entry. An entry may have only one editor
 * at one time; if a value is not available to be edited then [edit] will return null.
 *

  }

  /** Window update frames have special formatting.  */
  @Test
  fun windowUpdateFrames() {
    assertThat(frameLogWindowUpdate(false, 0, 4, Int.MAX_VALUE.toLong()))
      .isEqualTo(">> 0x00000000     4 WINDOW_UPDATE 2147483647")
    assertThat(frameLogWindowUpdate(true, 101, 4, 1))
      .isEqualTo("<< 0x00000065     4 WINDOW_UPDATE 1")
  }

  @Test
  fun flagOverlapOn0x1() {

  /** Returns an output stream where the request body can be streamed. */
  @Throws(IOException::class)
  fun createRequestBody(
    request: Request,
    contentLength: Long,
  ): Sink

  /** This should update the HTTP engine's sentRequestMillis field. */
  @Throws(IOException::class)
  fun writeRequestHeaders(request: Request)

  /** Flush the request to the underlying socket. */
  @Throws(IOException::class)