} catch (e: IOException) {
            // It is ok if this broke the stream.
            bodyRef.set("A")
            throw e // We expect to not loop into onFailure in this case.
          } finally {
            latch.countDown()
          }
        }
      },
    )
    latch.await()
    assertThat(bodyRef.get()).isEqualTo("A")

   * authenticator. This gives the authenticator the option to customize the CONNECT request. It can
   * decline to do so by returning null, in which case OkHttp will use it as-is.
   */
  @Throws(IOException::class)
  private fun createTunnelRequest(route: Route): Request {
    val proxyConnectRequest =
      Request.Builder()
        .url(route.address.url)

    assertThat(server.takeRequest().sequenceNumber).isEqualTo(1)
  }

  /**
   * Test to ensure we don't  throw a read timeout on responses that are progressing.  For this
   * case, we take a 4KiB body and throttle it to 1KiB/second.  We set the read timeout to two
   * seconds.  If our implementation is acting correctly, it will not throw, as it is progressing.
   */
  @ParameterizedTest

     *   attempt multiple proxy servers in sequence, eventually falling back to a direct
     *   connection.
     *
     * Set this to false to avoid retrying requests when doing so is destructive. In this case the
     * calling application should do its own recovery of connectivity failures.
     */
    fun retryOnConnectionFailure(retryOnConnectionFailure: Boolean) =
      apply {

   * the stream (asynchronously) which will notify the waiting thread.
   */
  internal inner class StreamTimeout : AsyncTimeout() {
    override fun timedOut() {
      closeLater(ErrorCode.CANCEL)
      connection.sendDegradedPingLater()
    }

    override fun newTimeoutException(cause: IOException?): IOException {

    ```
    val request = Request(
      url = "https://cash.app/".toHttpUrl(),
    )
    ```

 *  New: `Response.body` is now non-null. This was generally the case in OkHttp 4.x, but the Kotlin
    type declaration was nullable to support rare cases like the body on `Response.cacheResponse`,
    `Response.networkResponse`, and `Response.priorResponse`. In such cases the body is now

   * `HttpURLConnection` who flushes more bytes to the output stream than the connection's write
   * window will block.
   *
   * Zero [byteCount] writes are not subject to flow control and will not block. The only use case
   * for zero [byteCount] is closing a flushed output stream.
   */
  @Throws(IOException::class)
  fun writeData(
    streamId: Int,
    outFinished: Boolean,
    buffer: Buffer?,
    byteCount: Long,

      field = protocolList
    }

  var started: Boolean = false
  private var shutdown: Boolean = false

  @Synchronized private fun before() {
    if (started) return // Don't call start() in case we're already shut down.
    try {
      start()
    } catch (e: IOException) {
      throw RuntimeException(e)
    }
  }

  fun toProxyAddress(): Proxy {
    before()

        packageListUrl.set(URI.create("https://square.github.io/okio/3.x/okio/okio/package-list").toURL())
      }
    }
  }

  plugins.withId("com.vanniktech.maven.publish.base") {
    val publishingExtension = extensions.getByType(PublishingExtension::class.java)
    configure<MavenPublishBaseExtension> {
      publishToMavenCentral(SonatypeHost.S01, automaticRelease = true)

) {
  private val moshi = Moshi.Builder().build()

  private val moshiConverterFactory = MoshiConverterFactory.create(moshi)

  private val retrofit =
    Retrofit.Builder()
      .baseUrl(SslLabsApi.BASE_URL)
      .addConverterFactory(moshiConverterFactory)
      .callFactory(callFactory)
      .build()

  private val sslLabsApi = retrofit.create(SslLabsApi::class.java)

  suspend fun clients(): List<Client> {