@Override public void dnsEnd(Call call, String domainName, List<InetAddress> inetAddressList) {
      printEvent("dnsEnd");
    }

    @Override public void connectStart(
        Call call, InetSocketAddress inetSocketAddress, Proxy proxy) {
      printEvent("connectStart");
    }

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

  }

  override fun removePlanToCancel(connectPlan: ConnectPlan) {
  }

  override fun updateRouteDatabaseAfterSuccess(route: Route) {
  }

  override fun connectStart(route: Route) {
  }

  override fun secureConnectStart() {
  }

  override fun secureConnectEnd(handshake: Handshake?) {
  }

  override fun callConnectEnd(
    route: Route,

	var dialStart, dialEnd int64
	start := time.Now()
	trace := &httptrace.ClientTrace{
		GotFirstResponseByte: func() {
			atomic.AddUint64(&globalStats.tcpTimeForFirstByteTotalDur, uint64(time.Since(start)))
		},
		ConnectStart: func(network, addr string) {
			atomic.StoreInt64(&dialStart, time.Now().UnixNano())
		},
		ConnectDone: func(network, addr string, err error) {
			if err == nil {
				atomic.StoreInt64(&dialEnd, time.Now().UnixNano())

    val latch2 = CountDownLatch(1)
    val latch3 = CountDownLatch(1)
    val latch4 = CountDownLatch(1)
    val listener1: EventListener =
      object : EventListener() {
        override fun connectStart(
          call: Call,
          inetSocketAddress: InetSocketAddress,
          proxy: Proxy,
        ) {
          try {

    expectedEvents += "CallStart"
    expectedEvents += "ProxySelectStart"
    expectedEvents += "ProxySelectEnd"
    expectedEvents += "DnsStart"
    expectedEvents += "DnsEnd"
    expectedEvents += "ConnectStart"
    if (https) {
      expectedEvents += "SecureConnectStart"
      expectedEvents += "SecureConnectEnd"
    }
    expectedEvents += "ConnectEnd"
    expectedEvents += "ConnectionAcquired"

    listener.assertClose()
    assertThat(eventListener.recordedEventTypes()).containsExactly(
      "CallStart",
      "ProxySelectStart",
      "ProxySelectEnd",
      "DnsStart",
      "DnsEnd",
      "ConnectStart",
      "ConnectEnd",
      "ConnectionAcquired",
      "RequestHeadersStart",
      "RequestHeadersEnd",
      "ResponseHeadersStart",
      "ResponseHeadersEnd",
      "ResponseBodyStart",

	public fun connectFailed (Lokhttp3/Call;Ljava/net/InetSocketAddress;Ljava/net/Proxy;Lokhttp3/Protocol;Ljava/io/IOException;)V
	public fun connectStart (Lokhttp3/Call;Ljava/net/InetSocketAddress;Ljava/net/Proxy;)V
	public fun connectionAcquired (Lokhttp3/Call;Lokhttp3/Connection;)V
	public fun connectionReleased (Lokhttp3/Call;Lokhttp3/Connection;)V

pkg net/http/httptrace, type ClientTrace struct
pkg net/http/httptrace, type ClientTrace struct, ConnectDone func(string, string, error)
pkg net/http/httptrace, type ClientTrace struct, ConnectStart func(string, string)
pkg net/http/httptrace, type ClientTrace struct, DNSDone func(DNSDoneInfo)
pkg net/http/httptrace, type ClientTrace struct, DNSStart func(DNSStartInfo)

    check(rawSocket == null) { "TCP already connected" }

    var success = false

    // Tell the call about the connecting call so async cancels work.
    user.addPlanToCancel(this)
    try {
      user.connectStart(route)

      connectSocket()
      success = true
      return ConnectResult(plan = this)
    } catch (e: IOException) {
      user.connectFailed(route, null, e)

      assertEquals(200, response.code)
    }

    assertEquals(
      listOf(
        "CallStart", "ProxySelectStart", "ProxySelectEnd", "DnsStart", "DnsEnd",
        "ConnectStart", "SecureConnectStart", "SecureConnectEnd", "ConnectEnd",
        "ConnectionAcquired", "RequestHeadersStart", "RequestHeadersEnd", "ResponseHeadersStart",