assertThat(server2.requestCount).isEqualTo(1)

    assertThat(clientTestRule.recordedConnectionEventTypes()).containsExactly(
      "ConnectStart",
      "ConnectEnd",
      "ConnectionAcquired",
      "NoNewExchanges",
      "ConnectionReleased",
      "ConnectionClosed",
      "ConnectStart",
      "ConnectEnd",
      "ConnectionAcquired",
      "ConnectionReleased",
    )
  }

  @Test

    val expectedAddress = InetSocketAddress(address, server.port)
    val connectStart: ConnectStart =
      eventRecorder.removeUpToEvent<ConnectStart>()
    assertThat(connectStart.call).isSameAs(call)
    assertThat(connectStart.inetSocketAddress).isEqualTo(expectedAddress)
    assertThat(connectStart.proxy).isEqualTo(
      server.proxyAddress,
    )

      )
    val response = call.execute()
    assertThat(response.code).isEqualTo(200)
    response.body.close()
    assertThat(listener.recordedEventTypes()).containsExactly(
      "ConnectStart",
      "ConnectFailed",
      "ConnectStart",
      "ConnectEnd",
      "ConnectionAcquired",
      "ConnectionReleased",
    )
  }

  @Test
  @Throws(IOException::class)
  fun successfulHttpProxyConnect() {

    // JDK 14
    // CallStart, ProxySelectStart, ProxySelectEnd, DnsStart, DnsEnd, ConnectStart, SecureConnectStart,
    // SecureConnectEnd, ConnectEnd, ConnectionAcquired, RequestHeadersStart, RequestHeadersEnd,
    // ResponseFailed, ConnectionReleased, CallFailed
    // JDK 8
    // CallStart, ProxySelectStart, ProxySelectEnd, DnsStart, DnsEnd, ConnectStart, SecureConnectStart,
    // ConnectFailed, CallFailed
    // Gradle - JDK 11

        if (connectionType != H2) {
          addAll(listOf("ConnectStart", "ConnectEnd"))
        }
        addAll(listOf("ConnectionAcquired", "ConnectionReleased", "CallEnd"))
      }

    assertThat(events2).isEqualTo(expectedEvents2)
  }

  private fun isConnectionEvent(it: CallEvent?) =
    it is CallStart ||
      it is CallEnd ||
      it is ConnectStart ||
      it is ConnectEnd ||

import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.SocketEffect.CloseStream
import okhttp3.CallEvent.ConnectEnd
import okhttp3.CallEvent.ConnectFailed
import okhttp3.CallEvent.ConnectStart
import okhttp3.internal.http2.ErrorCode
import okhttp3.testing.Flaky
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Timeout

    domainName: String,
    inetAddressList: List<InetAddress>,
  ) = onEvent(DnsEnd(System.nanoTime(), call, domainName, inetAddressList))

  override fun connectStart(
    call: Call,
    inetSocketAddress: InetSocketAddress,
    proxy: Proxy,
  ) = onEvent(ConnectStart(System.nanoTime(), call, inetSocketAddress, proxy))

  override fun secureConnectStart(call: Call) =
    onEvent(
      SecureConnectStart(

import mockwebserver3.MockWebServer
import mockwebserver3.junit5.StartStop
import okhttp3.CallEvent.CallEnd
import okhttp3.CallEvent.CallStart
import okhttp3.CallEvent.ConnectEnd
import okhttp3.CallEvent.ConnectStart
import okhttp3.CallEvent.ConnectionAcquired
import okhttp3.CallEvent.ConnectionReleased
import okhttp3.CallEvent.DnsEnd
import okhttp3.CallEvent.DnsStart
import okhttp3.CallEvent.FollowUpDecision

    domainName: String,
    inetAddressList: List<InetAddress>,
  ) {
    logWithTime("dnsEnd: $inetAddressList")
  }

  override fun connectStart(
    call: Call,
    inetSocketAddress: InetSocketAddress,
    proxy: Proxy,
  ) {
    logWithTime("connectStart: $inetSocketAddress $proxy")
  }

  override fun secureConnectStart(call: Call) {
    logWithTime("secureConnectStart")
  }

        delegate.dnsEnd(call, domainName, inetAddressList)
      }
    }

    override fun connectStart(
      call: Call,
      inetSocketAddress: InetSocketAddress,
      proxy: Proxy,
    ) {
      for (delegate in eventListeners) {
        delegate.connectStart(call, inetSocketAddress, proxy)
      }
    }

    override fun secureConnectStart(call: Call) {