dispatcher.maxRequests = 2 // Trigger promotion.
    callback.await(request2.url).assertFailure(InterruptedIOException::class.java)
    assertThat(listener.recordedEventTypes())
      .containsExactly("CallStart", "CallStart", "CallFailed")
  }

  @Test
  fun executionRejectedAfterMaxRequestsPerHostChange() {
    val request1 = newRequest("http://a/1")
    val request2 = newRequest("http://a/2")

    }

    // Observed Events are variable
    // 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,

    timeout.enter()
    callStart()
    try {
      client.dispatcher.executed(this)
      return getResponseWithInterceptorChain()
    } finally {
      client.dispatcher.finished(this)
    }
  }

  override fun enqueue(responseCallback: Callback) {
    check(executed.compareAndSet(false, true)) { "Already Executed" }

    callStart()

      mutableListOf<String>().apply {
        add("CallStart")
        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 ||

   *
   * This will be invoked only once for a single [Call]. Retries of different routes or redirects
   * will be handled within the boundaries of a single [callStart] and [callEnd]/[callFailed] pair.
   */
  open fun callStart(call: Call) {
  }

  /**
   * Invoked prior to a proxy selection.
   *
   * This will be invoked for route selection regardless of whether the client

        .build(),
    )
    val response = client.newCall(request().build()).execute()
    assertThat(response.body).isNotNull()
    response.body.bytes()
    logRecorder
      .assertLogMatch(Regex("""callStart: Request\{method=GET, url=$url\}"""))
      .assertLogMatch(Regex("""proxySelectStart: $url"""))
      .assertLogMatch(Regex("""proxySelectEnd: \[DIRECT]"""))
      .assertLogMatch(Regex("""dnsStart: ${url.host}"""))

    client.newCall(request).execute().use { response ->
      assertEquals(200, response.code)
    }

    assertEquals(
      listOf(
        "CallStart", "ProxySelectStart", "ProxySelectEnd", "DnsStart", "DnsEnd",
        "ConnectStart", "SecureConnectStart", "SecureConnectEnd", "ConnectEnd",

      requestBody.writeUtf8("request A\n")
      requestBody.close()
    }
    body.awaitSuccess()
    assertThat(listener.recordedEventTypes()).containsExactly(
      "CallStart", "ProxySelectStart", "ProxySelectEnd", "DnsStart", "DnsEnd", "ConnectStart",
      "SecureConnectStart", "SecureConnectEnd", "ConnectEnd", "ConnectionAcquired",

    var dns: Dns = Dns { TODO() }

    val system: Dns = Dns.SYSTEM
  }

  @Test
  fun eventListener() {
    val eventListener =
      object : EventListener() {
        override fun callStart(call: Call) = TODO()

        override fun dnsStart(
          call: Call,
          domainName: String,
        ) = TODO()

        override fun dnsEnd(
          call: Call,