poolConnectionListener.connectFailed(route, call, e)
  }

  override fun secureConnectStart() {
    eventListener.secureConnectStart(call)
  }

  override fun secureConnectEnd(handshake: Handshake?) {
    eventListener.secureConnectEnd(call, handshake)
  }

  override fun callConnectEnd(
    route: Route,
    protocol: Protocol?,
  ) {
    eventListener.connectEnd(call, route.socketAddress, route.proxy, protocol)
  }

 * Keep whichever TCP connection succeeds first and cancel all the others.
 * Race TCP only. Only attempt a TLS handshake on the winning TCP connection.

        .build(),
    )
    val call = client.newCall(Request.Builder().url(server.url("/")).build())
    val response = call.execute()
    assertThat(response.handshake!!.peerPrincipal)
      .isEqualTo(X500Principal("CN=Local Host"))
    assertThat(response.handshake!!.localPrincipal)
      .isEqualTo(X500Principal("CN=Jethro Willis"))
    assertThat(response.body.string()).isEqualTo("abc")
  }

  @Test

  fun removePlanToCancel(connectPlan: ConnectPlan)

  fun updateRouteDatabaseAfterSuccess(route: Route)

  fun connectStart(route: Route)

  fun secureConnectStart()

  fun secureConnectEnd(handshake: Handshake?)

  fun callConnectEnd(
    route: Route,
    protocol: Protocol?,
  )

  fun connectionConnectEnd(
    connection: Connection,
    route: Route,
  )

  fun connectFailed(

  override fun updateRouteDatabaseAfterSuccess(route: Route) {
  }

  override fun connectStart(route: Route) {
  }

  override fun secureConnectStart() {
  }

  override fun secureConnectEnd(handshake: Handshake?) {
  }

  override fun callConnectEnd(
    route: Route,
    protocol: Protocol?,
  ) {
  }

  override fun connectionConnectEnd(
    connection: Connection,
    route: Route,
  ) {
  }

    response.use {
      assertEquals(Protocol.HTTP_2, response.protocol)
      if (Build.VERSION.SDK_INT >= 29) {
        assertEquals(TlsVersion.TLS_1_3, response.handshake?.tlsVersion)
      } else {
        assertEquals(TlsVersion.TLS_1_2, response.handshake?.tlsVersion)
      }
      assertEquals(200, response.code)
      assertTrue(socketClass?.startsWith("com.android.org.conscrypt.") == true)
    }

      printEvent("connectStart");
    }

    @Override public void secureConnectStart(Call call) {
      printEvent("secureConnectStart");
    }

    @Override public void secureConnectEnd(Call call, Handshake handshake) {
      printEvent("secureConnectEnd");
    }

    @Override public void connectEnd(
        Call call, InetSocketAddress inetSocketAddress, Proxy proxy, Protocol protocol) {
      printEvent("connectEnd");

      assertThat(it.handshake!!.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)
    }
  }

  @Test
  @Disabled
  fun testGoogle() {
    assumeNetwork()

    val request = Request.Builder().url("https://google.com/robots.txt").build()

    client.newCall(request).execute().use {
      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)
      if (it.handshake!!.tlsVersion != TlsVersion.TLS_1_3) {

    logWithTime("secureConnectStart")

    delegate.secureConnectStart(call)
  }

  override fun secureConnectEnd(
    call: Call,
    handshake: Handshake?,
  ) {
    logWithTime("secureConnectEnd: $handshake")

    delegate.secureConnectEnd(call, handshake)
  }

  override fun connectEnd(
    call: Call,
    inetSocketAddress: InetSocketAddress,
    proxy: Proxy,
    protocol: Protocol?,

    .build();
```

### Debugging TLS Handshake Failures

The TLS handshake requires clients and servers to share a common TLS version and cipher suite. This
depends on the JVM or Android version, OkHttp version, and web server configuration. If there is no
common cipher suite and TLS version, your call will fail like this:

```
Caused by: javax.net.ssl.SSLProtocolException: SSL handshake aborted: ssl=0x7f2719a89e80: