// In the process we made one successful connection attempt.
    assertThat(listener.recordedEventTypes().filter { it == "ConnectStart" }).hasSize(2)
    assertThat(listener.recordedEventTypes().filter { it == "ConnectFailed" }).hasSize(1)
    assertThat(listener.recordedEventTypes().filter { it == "ConnectEnd" }).hasSize(1)
  }

  @Test
  fun reachesIpv6WhenIpv4IsDown() {
    serverIpv4.shutdown()

      )
    val response = call.execute()
    assertThat(response.code).isEqualTo(200)
    assertThat(response.body.string()).isEqualTo("abc")
    response.body.close()
    assertThat(listener.recordedEventTypes()).containsExactly(
      "CallStart",
      "ProxySelectStart", "ProxySelectEnd", "DnsStart", "DnsEnd",
      "ConnectStart", "ConnectEnd", "ConnectionAcquired", "RequestHeadersStart",

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

  @Test
  fun failedCallEventSequence() {
    server!!.enqueue(

    // SecureConnectEnd, ConnectFailed, CallFailed
    val recordedEventTypes = listener.recordedEventTypes()
    assertThat(recordedEventTypes).startsWith(
      "CallStart",
      "ProxySelectStart",
      "ProxySelectEnd",
      "DnsStart",
      "DnsEnd",
      "ConnectStart",
      "SecureConnectStart",
    )
    assertThat(recordedEventTypes).endsWith("CallFailed")
  }

  private fun buildClient(

    val request = newRequest("http://a/1")
    executor.shutdown()
    client.newCall(request).enqueue(callback)
    callback.await(request.url).assertFailure(InterruptedIOException::class.java)
    assertThat(listener.recordedEventTypes())
      .containsExactly("CallStart", "CallFailed")
  }

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

    assertThat(source.request().url.encodedPath).isEqualTo("/")
    listener.assertOpen()
    listener.assertEvent(null, null, "hey")
    listener.assertClose()
    assertThat(eventListener.recordedEventTypes()).containsExactly(
      "CallStart",
      "ProxySelectStart",
      "ProxySelectEnd",
      "DnsStart",
      "DnsEnd",
      "ConnectStart",
      "ConnectEnd",
      "ConnectionAcquired",

      assertThat(
        TimeUnit.NANOSECONDS.toMillis(actualElapsedNs)
          .toDouble(),
      )
        .isCloseTo(elapsedMs.toDouble(), 100.0)
    }

    return result
  }

  fun recordedEventTypes() = eventSequence.map { it.name }

  fun clearAllEvents() {
    while (eventSequence.isNotEmpty()) {
      takeEvent()
    }
  }

  private fun logEvent(e: ConnectionEvent) {

      val requestBody = (call.request().body as AsyncRequestBody?)!!.takeSink()
      requestBody.writeUtf8("request A\n")
      requestBody.close()
    }
    body.awaitSuccess()
    assertThat(listener.recordedEventTypes()).containsExactly(
      "CallStart", "ProxySelectStart", "ProxySelectEnd", "DnsStart", "DnsEnd", "ConnectStart",
      "SecureConnectStart", "SecureConnectEnd", "ConnectEnd", "ConnectionAcquired",

        "ResponseHeadersEnd", "ResponseBodyStart", "ResponseBodyEnd", "ConnectionReleased",
        "CallEnd",
      ),
      eventListener.recordedEventTypes(),
    )

    eventListener.clearAllEvents()

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

    assertEquals(
      listOf(

    expectedEvents += "ResponseBodyStart"
    expectedEvents += "ResponseBodyEnd"
    expectedEvents += "ConnectionReleased"
    expectedEvents += "CallEnd"
    assertThat(listener.recordedEventTypes()).isEqualTo(expectedEvents)

    // Confirm that the connection pool was not corrupted by making another call.
    makeSimpleCall()
  }

  /**