alreadyEncoded = true,
                strict = true,
                plusIsSpace = true,
              )
          }
        }

        encodedFragment =
          encodedFragment?.canonicalize(
            encodeSet = FRAGMENT_ENCODE_SET_URI,
            alreadyEncoded = true,
            strict = true,
            unicodeAllowed = true,
          )
      }

        val alpnClass = Class.forName(alpnClassName, true, null)
        val providerClass = Class.forName("$alpnClassName\$Provider", true, null)
        val clientProviderClass = Class.forName("$alpnClassName\$ClientProvider", true, null)
        val serverProviderClass = Class.forName("$alpnClassName\$ServerProvider", true, null)
        val putMethod = alpnClass.getMethod("put", SSLSocket::class.java, providerClass)

    object : Runnable {
      override fun run() {
        var incrementedRunCallCount = false
        while (true) {
          val task =
            ******@****.***ck {
              if (!incrementedRunCallCount) {
                incrementedRunCallCount = true
                runCallCount++
              }
              awaitTaskToRun()
            } ?: return

    socket.enabledCipherSuites = arrayOf("SSL_A")
    val connectionSpec =
      ConnectionSpec.Builder(true)
        .tlsVersions(TlsVersion.TLS_1_0)
        .cipherSuites("SSL_A")
        .build()
    applyConnectionSpec(connectionSpec, socket, true)
    assertArrayEquals(
      arrayOf("SSL_A", "SSL_FALLBACK_SCSV"),
      socket.enabledCipherSuites,
    )
  }

  @Test

    socketFactory[ipv6] = server1.inetSocketAddress
    socketFactory[ipv4] = server2.inetSocketAddress

    client =
      client.newBuilder()
        .fastFallback(true)
        .apply {
          retryOnConnectionFailure = true
        }
        .build()

    executeSynchronously(request)
      .assertBody("body")

    assertThat(client.routeDatabase.failedRoutes).isEmpty()

    taskRunner.lock.withLock {
      yieldUntil()
    }
  }

  /** Process the queue until [condition] returns true. */
  private tailrec fun yieldUntil(
    strategy: ResumePriority = ResumePriority.AfterEnqueuedTasks,
    condition: () -> Boolean = { true },
  ) {
    taskRunner.assertThreadHoldsLock()
    val self = currentTask

    val yieldCompleteTask =
      object : SerialTask {

  }
  return -1
}

/** Returns true if we should void putting this this header in an exception or toString(). */
internal fun isSensitiveHeader(name: String): Boolean {
  return name.equals("Authorization", ignoreCase = true) ||
    name.equals("Cookie", ignoreCase = true) ||
    name.equals("Proxy-Authorization", ignoreCase = true) ||
    name.equals("Set-Cookie", ignoreCase = true)
}

internal fun Char.parseHexDigit(): Int =

            if (partCount == 0) throw ProtocolException("expected at least 1 part")
            noMoreParts = true
            return null
          }

          2, 3 -> {
            // " " or "\t" Ignore whitespace and keep looking.
            whitespace = true
            continue@afterBoundaryLoop
          }

          -1 -> throw ProtocolException("unexpected characters after boundary")

        }
        "private".equals(directive, ignoreCase = true) -> {
          isPrivate = true
        }
        "public".equals(directive, ignoreCase = true) -> {
          isPublic = true
        }
        "must-revalidate".equals(directive, ignoreCase = true) -> {
          mustRevalidate = true
        }
        "max-stale".equals(directive, ignoreCase = true) -> {

  }
  return builder.build()
}

internal fun Headers.toHeaderList(): List<Header> =
  (0 until size).map {
    Header(name(it), value(it))
  }

/** Returns true if an HTTP request for this URL and [other] can reuse a connection. */
internal fun HttpUrl.canReuseConnectionFor(other: HttpUrl): Boolean =
  host == other.host &&
    port == other.port &&
    scheme == other.scheme