@RegisterExtension
  val platform = PlatformRule()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()
  private lateinit var server: MockWebServer
  private val handshakeCertificates = platform.localhostHandshakeCertificates()
  private val logRecorder =
    HttpLoggingInterceptorTest.LogRecorder(
      prefix = Regex("""\[\d+ ms] """),
    )

    override val timestampNs: Long,
    val route: Route,
    val call: Call,
    val exception: IOException,
  ) : ConnectionEvent() {
    override fun closes(event: ConnectionEvent): Boolean = event is ConnectStart && call == event.call && route == event.route
  }

  data class ConnectEnd(
    override val timestampNs: Long,
    override val connection: Connection,
    val route: Route,
    val call: Call,

            if (!isInBuildLogic) { // BuildScanExtension is only available in the gradle project
                val buildScan = gradleRootProject.extensions.findByType<BuildScanConfiguration>()
                val infoCollectedInBuildLogic = gradleRootProject.extensions.extraProperties.get("collectedInfo-${klass.simpleName}-build-logic")!!

    @VisibleForTesting
    data class AcceptedApiChange(
        val type: String?,
        val member: String?,
        val acceptation: String?,
        val changes: List<String>?
    ) {
        override fun toString(): String = "Type: '$type', Member: '$member'"
    }

    @VisibleForTesting
    data class AcceptedApiChanges(
        val acceptedApiChanges: List<AcceptedApiChange>?
    )

import org.junit.jupiter.api.extension.RegisterExtension
import org.junit.jupiter.api.fail

class ExecuteAsyncTest {
  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  private var client = clientTestRule.newClientBuilder().build()

  private lateinit var server: MockWebServer

  val request by lazy { Request(server.url("/")) }

  @BeforeEach
  fun setup(server: MockWebServer) {
    this.server = server
  }

  @RegisterExtension
  val platform = PlatformRule()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  private lateinit var server1: MockWebServer
  private lateinit var server2: MockWebServer

  private var listener = RecordingEventListener()

  private val handshakeCertificates = platform.localhostHandshakeCertificates()

  val dns = FakeDns()

        val textReport = parameters.textReportFile.get().asFile
        textReport.parentFile.mkdirs()
        textReport.printWriter(Charsets.UTF_8).use { writer ->
            val versions = versionsDates()
            versionToIncubating.toSortedMap().forEach { (version, incubatingDescriptions) ->
                val releaseDate = versions[version] ?: "unreleased"

  val okhttp = currentOkHttp(ianaSuitesNew)

  val okHttp_4_10 = historicOkHttp("4.10")
  val okHttp_3_14 = historicOkHttp("3.14")
  val okHttp_3_13 = historicOkHttp("3.13")
  val okHttp_3_11 = historicOkHttp("3.11")
  val okHttp_3_9 = historicOkHttp("3.9")

  val currentVm = currentVm(ianaSuitesNew)

  val conscrypt =
    if (includeConscrypt) {

      return statusParts[2]
    }

  val headers: Headers
  val trailers: Headers

  // At most one of (body,webSocketListener,streamHandler) is non-null.
  val body: MockResponseBody?
  val webSocketListener: WebSocketListener?
  val streamHandler: StreamHandler?

  val inTunnel: Boolean
  val informationalResponses: List<MockResponse>

  val throttleBytesPerPeriod: Long
  val throttlePeriodNanos: Long

   * as attempting IPv6 first, can make such decisions.
   */
  @ExperimentalOkHttpApi
  enum class DnsClass(val type: Int) {
    IPV4(TYPE_A),
    IPV6(TYPE_AAAA),
  }

  @ExperimentalOkHttpApi
  companion object {
    const val TYPE_A = 1
    const val TYPE_AAAA = 28

    /**
     * Adapt an AsyncDns implementation to Dns, waiting until onComplete is received