SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY -> result.onResponseBody(CloseSocket())
    SocketPolicy.DO_NOT_READ_REQUEST_BODY -> result.doNotReadRequestBody()
    SocketPolicy.FAIL_HANDSHAKE -> result.failHandshake()
    SocketPolicy.SHUTDOWN_INPUT_AT_END ->
      result.onResponseEnd(
        CloseSocket(
          closeSocket = false,
          shutdownInput = true,
        ),
      )

    assertThat(event.route.socketAddress).isEqualTo(expectedAddress)
  }

  @Test
  @Throws(UnknownHostException::class)
  fun failedConnect() {
    enableTls()
    server.enqueue(MockResponse.Builder().failHandshake().build())
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )
    assertFailsWith<IOException> {

    assertThat(connectEnd.protocol).isEqualTo(Protocol.HTTP_1_1)
  }

  @Test
  fun failedConnect() {
    enableTlsWithTunnel()
    server.enqueue(
      MockResponse
        .Builder()
        .failHandshake()
        .build(),
    )
    val call =
      client.newCallWithListener(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )

    server.enqueue(MockResponse.Builder().failHandshake().build())
    server.enqueue(MockResponse(body = "response that will never be received"))
    val response = executeSynchronously("/")
    response.assertFailure(
      // JDK 11 response to the FAIL_HANDSHAKE:
      SSLException::class.java,
      // RI response to the FAIL_HANDSHAKE:
      SSLProtocolException::class.java,

      if (!processTunnelRequests()) return

      val protocol: Protocol
      val socket: MockWebServerSocket
      when {
        sslSocketFactory != null -> {
          if (firstExchangePeek.failHandshake) {
            dispatchBookkeepingRequest(
              connectionIndex = connectionIndex,
              exchangeIndex = nextExchangeIndex++,
              socket = MockWebServerSocket(raw),
            )