println("Proxy Server 1 is ${server1.socketAddress}")
    println("Proxy Server 2 is ${server2.socketAddress}")

    // Since myproxy:8008 won't resolve, redirect with DNS to proxyServer1
    // Then redirect socket connection to server1
    dns["myproxy"] = listOf(proxyServer1)
    socketFactory[proxyServer1] = server1.socketAddress

    client = client.newBuilder().proxySelector(proxySelector).build()

   * of the request.
   */
  public var dispatcher: Dispatcher = QueueDispatcher()

  public val socketAddress: InetSocketAddress
    get() = socketAddress_ ?: error("call start() first")

  public val port: Int
    get() = socketAddress.port

  public val hostName: String
    get() = socketAddress.address.hostName

  /** Returns the address of this server, to connect to it as an HTTP proxy. */

    assertThat(socketAddress.socketHost).isEqualTo("127.0.0.1")

    // InetAddress proxy specification.
    socketAddress = InetSocketAddress(InetAddress.getByName("localhost"), 1234)
    assertThat(socketAddress.socketHost).isEqualTo("127.0.0.1")
    socketAddress = InetSocketAddress(InetAddress.getByAddress(byteArrayOf(127, 0, 0, 1)), 1234)
    assertThat(socketAddress.socketHost).isEqualTo("127.0.0.1")
    socketAddress =
      InetSocketAddress(

    requestedUris.clear()
  }

  override fun connectFailed(
    uri: URI,
    sa: SocketAddress,
    ioe: IOException,
  ) {
    val socketAddress = sa as InetSocketAddress
    failures.add(format("%s %s:%d %s", uri, socketAddress, socketAddress.port, ioe.message!!))
  }

  override fun toString() = "RecordingProxySelector"

    )

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

  fun newChain(call: RealCall): RealInterceptorChain =
    RealInterceptorChain(
      call = call,

    val proxySelector: ProxySelector =
      object : ProxySelector() {
        override fun select(uri: URI) = listOf(socksProxy.proxy())

        override fun connectFailed(
          uri: URI,
          socketAddress: SocketAddress,
          e: IOException,
        ) = error("unexpected call")
      }
    val client =
      clientTestRule
        .newClientBuilder()
        .proxySelector(proxySelector)
        .build()

            uri: URI?,
            sa: SocketAddress?,
            ioe: java.io.IOException?,
          ) {
          }
        }

      override val badValue: ProxySelector =
        object : ProxySelector() {
          override fun select(uri: URI?): MutableList<Proxy> = TODO()

          override fun connectFailed(
            uri: URI?,
            sa: SocketAddress?,
            ioe: java.io.IOException?,

    val proxySelector: ProxySelector =
      object : ProxySelector() {
        override fun select(uri: URI): List<Proxy> = listOf()

        override fun connectFailed(
          uri: URI,
          socketAddress: SocketAddress,
          e: IOException,
        ) {}
      }

    val trustManager = get().platformTrustManager()
    val sslContext = get().newSSLContext()
    sslContext.init(null, null, null)

      connection.start()

      // Success.
      call.eventListener.connectEnd(call, route.socketAddress, route.proxy, protocol)
      success = true
      return ConnectResult(plan = this)
    } catch (e: IOException) {
      call.eventListener.connectFailed(call, route.socketAddress, route.proxy, null, e)
      connectionPool.connectionListener.connectFailed(route, call, e)

    val expectedAddress = InetSocketAddress(address, server.port)
    val event = listener.removeUpToEvent(ConnectionEvent.ConnectStart::class.java)
    assertThat(event.route.socketAddress).isEqualTo(expectedAddress)
  }

  @Test
  @Throws(UnknownHostException::class)
  fun failedConnect() {
    enableTls()
    server.enqueue(MockResponse.Builder().failHandshake().build())
    val call =