// We need new data from upstream.
          while (true) {
            val upstreamPos = ******@****.***amPos
            if (sourcePos != upstreamPos) break

            // No more data upstream. We're done.
            if (complete) return -1L

            // Another thread is already reading. Wait for that.
            if (upstreamReader != null) {
              timeout.waitUntilNotified(this@Relay)

    lock.assertHeld()

    // If this connection is not accepting new exchanges, we're done.
    if (calls.size >= allocationLimit || noNewExchanges) return false

    // If the non-host fields of the address don't overlap, we're done.
    if (!this.route.address.equalsNonHost(address)) return false

    // If the host exactly matches, we're done: this connection can carry the address.

internal fun inet6AddressToAscii(address: ByteArray): String {
  // Go through the address looking for the longest run of 0s. Each group is 2-bytes.
  // A run must be longer than one group (section 4.2.2).
  // If there are multiple equal runs, the first one must be used (section 4.2.3).
  var longestRunOffset = -1
  var longestRunLength = 0
  run {
    var i = 0
    while (i < address.size) {
      val currentRunOffset = i

Note that OkHttp won't use compression when sending messages smaller than 1 KiB.

 *  Fix: Don't crash when the URL hostname contains an underscore on Android.
 *  Fix: Change HTTP/2 to use a daemon thread for its socket reader. If you've ever seen a command
    line application hang after all of the work is done, it may be due to a non-daemon thread like
    this one.
 *  New: Include suppressed exceptions when all routes to a target service fail.

    private val body: Sink
    var done = false

    init {
      this.body =
        object : ForwardingSink(cacheOut) {
          @Throws(IOException::class)
          override fun close() {
            synchronized(this@Cache) {
              if (done) return
              done = true
              writeSuccessCount++
            }
            super.close()

    @Volatile private var queryParamsNameToRedact = emptySet<String>()

    @set:JvmName("level")
    @Volatile
    var level = Level.NONE

    enum class Level {
      /** No logs. */
      NONE,

      /**
       * Logs request and response lines.
       *
       * Example:
       * ```
       * --> POST /greeting http/1.1 (3-byte body)
       *

     * may be started on the same key.
     */
    @Throws(IOException::class)
    fun commit() {
      synchronized(this@DiskLruCache) {
        check(!done)
        if (entry.currentEditor == this) {
          completeEdit(this, true)
        }
        done = true
      }
    }

    /**
     * Aborts this edit. This releases the edit lock so another edit may be started on the same
     * key.
     */

      // Attempt to get the trust manager from an OpenJDK socket factory. We attempt this on all
      // platforms in order to support Robolectric, which mixes classes from both Android and the
      // Oracle JDK. Note that we don't support HTTP/2 or other nice features on Robolectric.
      val sslContextClass = Class.forName("sun.security.ssl.SSLContextImpl")
      val context = readFieldOrNull(sslSocketFactory, sslContextClass, "context") ?: return null

import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
import okhttp3.testing.PlatformRule
import org.junit.jupiter.api.Test

@Suppress("HttpUrlsUsage") // Don't warn if we should be using https://.
open class HttpUrlJvmTest {
  val platform = PlatformRule()

  /** This one's ugly: the HttpUrl's host is non-empty, but the URI's host is null. */
  @Test
  fun hostContainsOnlyStrippedCharacters() {
    val url = "http://>/".toHttpUrl()

   * Otherwise this returns an empty list of challenges.
   *
   * If a challenge uses the `token68` variant instead of auth params, there is exactly one
   * auth param in the challenge at key null. Invalid headers and challenges are ignored.
   * No semantic validation is done, for example that `Basic` auth must have a `realm`
   * auth param, this is up to the caller that interprets these challenges.
   */