private const val PROXY_A_HOST = "proxya"
    private val proxyA =
      Proxy(
        Proxy.Type.HTTP,
        InetSocketAddress.createUnresolved(PROXY_A_HOST, PROXY_A_PORT),
      )

    private const val PROXY_B_PORT = 1002
    private const val PROXY_B_HOST = "proxyb"
    private val proxyB =
      Proxy(
        Proxy.Type.HTTP,

    }

    return Selection(routes)
  }

  /** Prepares the proxy servers to try. */
  private fun resetNextProxy(
    url: HttpUrl,
    proxy: Proxy?,
  ) {
    fun selectProxies(): List<Proxy> {
      // If the user specifies a proxy, try that and only that.
      if (proxy != null) return listOf(proxy)

      // If the URI lacks a host (as in "http://</"), don't call the ProxySelector.

    override val timestampNs: Long,
    override val call: Call,
    val inetSocketAddress: InetSocketAddress,
    val proxy: Proxy?,
  ) : CallEvent()

  data class ConnectEnd(
    override val timestampNs: Long,
    override val call: Call,
    val inetSocketAddress: InetSocketAddress,
    val proxy: Proxy?,
    val protocol: Protocol?,
  ) : CallEvent() {
    override fun closes(event: CallEvent): Boolean =

      connectionPool.connectionListener.connectStart(route, call)

      connectSocket()
      success = true
      return ConnectResult(plan = this)
    } catch (e: IOException) {
      // If we used the ProxySelector, and got a IOException during connect, report the failure.
      if (route.address.proxy == null && route.proxy.type() != Proxy.Type.DIRECT) {

  ) {
  }

  /**
   * Invoked after proxy selection.
   *
   * Note that the list of proxies is never null, but it may be a list containing
   * only [Proxy.NO_PROXY]. This comes up in several situations:
   *
   * * If neither a proxy nor proxy selector is configured.
   * * If the proxy is configured explicitly as [Proxy.NO_PROXY].
   * * If the proxy selector returns only [Proxy.NO_PROXY].

  override fun connectEnd(
    call: Call,
    inetSocketAddress: InetSocketAddress,
    proxy: Proxy,
    protocol: Protocol?,
  ) = onEvent(ConnectEnd(System.nanoTime(), call, inetSocketAddress, proxy, protocol))

  override fun connectFailed(
    call: Call,
    inetSocketAddress: InetSocketAddress,
    proxy: Proxy,
    protocol: Protocol?,
    ioe: IOException,
  ) = onEvent(
    ConnectFailed(

    )
  }

  @Test
  @Throws(IOException::class)
  fun successfulHttpProxyConnect() {
    server.enqueue(MockResponse())
    val proxy = server.proxyAddress
    client =
      client
        .newBuilder()
        .proxy(proxy)
        .build()
    val call =
      client.newCall(
        Request
          .Builder()
          .url("http://www.fakeurl")
          .build(),

  }

  override fun connectEnd(
    call: Call,
    inetSocketAddress: InetSocketAddress,
    proxy: Proxy,
    protocol: Protocol?,
  ) {
    logWithTime("connectEnd: $protocol")
  }

  override fun connectFailed(
    call: Call,
    inetSocketAddress: InetSocketAddress,
    proxy: Proxy,
    protocol: Protocol?,
    ioe: IOException,
  ) {
    logWithTime("connectFailed: $protocol $ioe")

      certificatePinner = null,
      proxyAuthenticator = proxyAuthenticator,
      proxy = proxy,
      protocols = protocols,
      connectionSpecs = connectionSpecs,
      proxySelector = proxySelector,
    )

  fun newRoute(
    address: Address = newAddress(),
    proxy: Proxy = this.proxy,
    socketAddress: InetSocketAddress = InetSocketAddress.createUnresolved(uriHost, uriPort),
  ): Route =

      }

    /**
     * Sets the HTTP proxy that will be used by connections created by this client. This takes
     * precedence over [proxySelector], which is only honored when this proxy is null (which it is
     * by default). To disable proxy use completely, call `proxy(Proxy.NO_PROXY)`.
     */
    fun proxy(proxy: Proxy?) =
      apply {
        if (proxy != this.proxy) {
          this.routeDatabase = null
        }