*/
  class AddressPolicy(
    /**
     * How many concurrent calls should be possible to make at any time.
     * The pool will routinely try to pre-emptively open connections to satisfy this minimum.
     * Connections will still be closed if they idle beyond the keep-alive but will be replaced.
     */
    @JvmField val minimumConcurrentCalls: Int = 0,

   * in practice. To simplify the implementation, we've avoided implementing the flexible rules in
   * favor of supporting what's actually used in practice. That means if these assertions ever fail,
   * the implementation will need to be revisited to support a more flexible rule.
   */
  private fun assertWildcardRule(rule: String) {
    check(rule.startsWith(WILDCARD_CHAR)) {
      """Wildcard Assertion Failure: '$rule'

  fun sendFrame(): Http2Writer {
    outFrames.add(OutFrame(frameCount++, bytesOut.size, false))
    return writer
  }

  /**
   * Shortens the last frame from its original length to `length`. This will cause the peer to
   * close the socket as soon as this frame has been written; otherwise the peer stays open until
   * explicitly closed.
   */
  fun truncateLastFrame(length: Int): Http2Writer {

  private const val INITIAL_BIAS = 72
  private const val INITIAL_N = 0x80

  /**
   * Returns null if any label is oversized so much that the encoder cannot encode it without
   * integer overflow. This will not return null for labels that fit within the DNS size
   * limits.
   */
  fun encode(string: String): String? {
    var pos = 0
    val limit = string.length
    val result = Buffer()

    while (pos < limit) {

    val acceptedIssuers = handshakeCertificates.trustManager.acceptedIssuers
    val names =
      acceptedIssuers
        .map { it.subjectDN.name }
        .toSet()

    // It's safe to assume all platforms will have a major Internet certificate issuer.
    assertThat(names).matchesPredicate { strings ->
      strings.any { it.matches(Regex("[A-Z]+=Entrust.*")) }
    }
  }

  private fun startTlsServer(): InetSocketAddress {

      // Postponed routes are always tried last. For example, if we have 2 proxies and all the
      // routes for proxy1 should be postponed, we'll move to proxy2. Only after we've exhausted
      // all the good routes will we attempt the postponed routes.
      val proxy = nextProxy()
      for (inetSocketAddress in inetSocketAddresses) {
        val route = Route(address, proxy, inetSocketAddress)
        if (routeDatabase.shouldPostpone(route)) {

   * waiting for the running calls to complete.
   *
   * If more than [maxRequests] requests are in flight when this is invoked, those requests will
   * remain in flight.
   */
  var maxRequests = 64
    get() = this.withLock { field }
    set(maxRequests) {
      require(maxRequests >= 1) { "max < 1: $maxRequests" }
      this.withLock {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.connection

/**
 * A RoutePlanner that will always establish a new connection, ignoring any connection pooling
 */
class ForceConnectRoutePlanner(private val delegate: RealRoutePlanner) : RoutePlanner by delegate {

    return List(elements.size / 2) { Header(elements[it * 2]!!, elements[it * 2 + 1]!!) }
  }

  @JvmStatic
  fun repeat(
    c: Char,
    count: Int,
  ): String {
    val array = CharArray(count)
    Arrays.fill(array, c)
    return String(array)
  }

  /**
   * Okio buffers are internally implemented as a linked list of arrays. Usually this implementation

 *
 * @return the index of the match. If no match is found this is `(-1 - insertionPoint)`, where the
 *     inserting the element at `insertionPoint` will retain sorted order.
 */
inline fun binarySearch(
  position: Int,
  limit: Int,
  compare: (Int) -> Int,
): Int {
  // Do the binary searching bit.
  var low = position
  var high = limit - 1