class CustomTrust {
  // PEM files for root certificates of Comodo and Entrust. These two CAs are sufficient to view
  // https://publicobject.com (Comodo) and https://squareup.com (Entrust). But they aren't
  // sufficient to connect to most HTTPS sites including https://godaddy.com and https://visa.com.
  // Typically developers will need to get a PEM file from their organization's TLS administrator.
  val comodoRsaCertificationAuthority =
    """

    val call1Connect = server.takeRequest()
    assertThat(call1Connect.method).isEqualTo("CONNECT")
    assertThat(call1Connect.sequenceNumber).isEqualTo(0)
    val call2Connect = server.takeRequest()
    assertThat(call2Connect.method).isEqualTo("CONNECT")
    assertThat(call2Connect.sequenceNumber).isEqualTo(0)
    val call2Get = server.takeRequest()

import okhttp3.Address
import okhttp3.HttpUrl
import okhttp3.Route
import okhttp3.internal.canParseAsIpAddress
import okhttp3.internal.immutableListOf
import okhttp3.internal.toImmutableList

/**
 * Selects routes to connect to an origin server. Each connection requires a choice of proxy server,
 * IP address, and TLS mode. Connections may also be recycled.
 */
class RouteSelector(
  private val address: Address,

    }
  }

  /**
   * This test reproduces a crash where OkHttp attempted to use a deferred connection when the call
   * already had a healthy connection. It sets up a deferred connection by stalling the IPv6
   * connect, and it sets up a same-connection retry with [ErrorCode.REFUSED_STREAM].
   *
   * https://github.com/square/okhttp/pull/7190
   */
  @Test
  fun preferCallConnectionOverDeferredConnection() {

  integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==

connect@^3.7.0:
  version "3.7.0"
  resolved "https://registry.yarnpkg.com/connect/-/connect-3.7.0.tgz#5d49348910caa5e07a01800b030d0c35f20484f8"
  integrity sha512-ZqRXc+tZukToSNmh5C2iWMSoV3X1YUcPbqEM4DkEG5tNQXrQUZCNVGGv3IuicnkMtPfGf3Xtp8WCXs295iQ1pQ==
  dependencies:

        request,
        clientListener,
        random,
        client.pingIntervalMillis.toLong(),
        null,
        0L,
        client.webSocketCloseTimeout.toLong(),
      )
    webSocket.connect(client)
    return webSocket
  }

  private fun closeWebSockets(
    client: WebSocket,
    server: WebSocket,
  ) {
    server.close(1001, "")
    clientListener.assertClosing(1001, "")

 * `http://square.github.io/dagger` and `http://google.github.io/dagger` are served by the same IP
 * address, the two URLs identify different resources.
 *
 * ### Port
 *
 * The port used to connect to the web server. By default this is 80 for HTTP and 443 for HTTPS.
 * This class never returns -1 for the port: if no port is explicitly specified in the URL then the
 * scheme's default is used.
 *
 * ### Path
 *

      }

      return when {
        tcpConnectThrowable != null -> {
          events += "plan $id TCP connect failed"
          ConnectResult(this, nextPlan = connectTcpNextPlan, throwable = tcpConnectThrowable)
        }
        canceled -> {
          events += "plan $id TCP connect canceled"
          ConnectResult(this, nextPlan = connectTcpNextPlan, throwable = IOException("canceled"))
        }

    val connect = planConnect()

    // Now that we have a set of IP addresses, make another attempt at getting a connection from
    // the pool. We have a better chance of matching thanks to connection coalescing.
    val pooled2 = planReusePooledConnection(connect, connect.routes)
    if (pooled2 != null) return pooled2

    return connect
  }

  /**

    delegate!!.bind(localAddr)
  }

  @Throws(IOException::class)
  override fun connect(remoteAddr: SocketAddress) {
    delegate!!.connect(remoteAddr)
  }

  @Throws(IOException::class)
  override fun connect(
    remoteAddr: SocketAddress,
    timeout: Int,
  ) {
    delegate!!.connect(remoteAddr, timeout)
  }

  override fun isInputShutdown(): Boolean {