*/
  private fun promoteAndExecute(): Boolean {
    assertLockNotHeld()

    val executableCalls = mutableListOf<AsyncCall>()
    val isRunning: Boolean
    synchronized(this) {
      val i = readyAsyncCalls.iterator()
      while (i.hasNext()) {
        val asyncCall = i.next()

        if (runningAsyncCalls.size >= this.maxRequests) break // Max capacity.

}

object Standard : SocketMode() {
  override fun toString(): String = "Standard"
}

data class TlsInstance(
  val provider: Provider,
  val protocol: Protocol,
  val tlsVersion: TlsVersion,
  val socketMode: SocketMode,
  val tlsExtensionMode: TlsExtensionMode,
) : SocketMode() {
  override fun toString(): String = "$provider/$protocol/$tlsVersion/$socketMode/$tlsExtensionMode"
}

    val delegate: BlockingQueue<T>,
  ) : AbstractQueue<T>(),
    BlockingQueue<T> {
    override val size: Int = delegate.size

    private var editCount = 0

    override fun poll(): T = delegate.poll()

    override fun poll(
      timeout: Long,
      unit: TimeUnit,
    ): T? {
      return taskRunner.withLock {
        val waitUntil = nanoTime + unit.toNanos(timeout)

 * IP address, and TLS mode. Connections may also be recycled.
 */
class RouteSelector(
  private val address: Address,
  private val routeDatabase: RouteDatabase,
  private val connectionUser: ConnectionUser,
  private val fastFallback: Boolean,
) {
  // State for negotiating the next proxy to use.
  private var proxies = emptyList<Proxy>()
  private var nextProxyIndex: Int = 0

class CallHandshakeTest {
  private lateinit var client: OkHttpClient

  @StartStop
  private val server = MockWebServer()

  @RegisterExtension
  @JvmField
  val clientTestRule = OkHttpClientTestRule()

  @RegisterExtension
  @JvmField
  var platform = PlatformRule()

  private val handshakeCertificates = platform.localhostHandshakeCertificates()

        .build()
    assertThat(body.parts.size).isEqualTo(1)
    val part1Buffer = Buffer()
    val part1 = body.part(0)
    part1.body.writeTo(part1Buffer)
    assertThat(part1.headers).isEqualTo(headersOf("Foo", "Bar"))
    assertThat(part1Buffer.readUtf8()).isEqualTo("Baz")
  }

  @Test
  fun nonAsciiFilename() {
    val expected =
      """
      |--AaB03x

 */
class Http2Reader(
  /** Creates a frame reader with max header table size of 4096. */
  private val source: BufferedSource,
  private val client: Boolean,
) : Closeable {
  private val continuation: ContinuationSource = ContinuationSource(this.source)
  private val hpackReader: Hpack.Reader =
    Hpack.Reader(
      source = continuation,
      headerTableSizeSetting = 4096,
    )

      headersOf("", "OkHttp")
    }
  }

  @Test fun ofAcceptsEmptyValue() {
    val headers = headersOf("User-Agent", "")
    assertThat(headers.value(0)).isEqualTo("")
  }

  @Test fun ofMakesDefensiveCopy() {
    val namesAndValues =
      arrayOf(
        "User-Agent",
        "OkHttp",
      )
    val headers = headersOf(*namesAndValues)
    namesAndValues[1] = "Chrome"

    } else {
      assertThat(event.t).isNull()
    }
  }

  internal data class Open(
    val eventSource: EventSource,
    val response: Response,
  )

  internal data class Failure(
    val t: Throwable?,
    val response: Response?,
    val message: String?,
  )

  internal object Closed

  fun fromUriUnsupportedScheme() {
    val uri = URI("mailto:******@****.***")
    assertThat(uri.toHttpUrlOrNull()).isNull()
  }

  @Test
  fun fromUriPartial() {
    val uri = URI("/path")
    assertThat(uri.toHttpUrlOrNull()).isNull()
  }

  @Test
  fun toJavaNetUrl() {
    val httpUrl = "http://username:password@host/path?query#fragment".toHttpUrl()
    val javaNetUrl = httpUrl.toUrl()