this.informationalResponses = builder.informationalResponses
    this.throttleBytesPerPeriod = builder.throttleBytesPerPeriod
    this.throttlePeriodNanos = builder.throttlePeriodNanos
    this.failHandshake = builder.failHandshake
    this.onRequestStart = builder.onRequestStart
    this.doNotReadRequestBody = builder.doNotReadRequestBody
    this.onRequestBody = builder.onRequestBody
    this.onResponseStart = builder.onResponseStart

    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.useHttps(handshakeCertificates.sslSocketFactory())
    server.protocols = Arrays.asList(Protocol.HTTP_2, Protocol.HTTP_1_1)
    server.enqueue(
      MockResponse
        .Builder()
        .failHandshake()
        .build(),
    )
    url = server.url("/")
    try {
      client.newCall(request().build()).execute()
      fail<Any>()
    } catch (expected: IOException) {
    }
    logRecorder

	public fun clone ()Lmockwebserver3/MockResponse$Builder;
	public final fun code (I)Lmockwebserver3/MockResponse$Builder;
	public final fun doNotReadRequestBody ()Lmockwebserver3/MockResponse$Builder;
	public final fun failHandshake ()Lmockwebserver3/MockResponse$Builder;
	public final fun getBody ()Lmockwebserver3/MockResponseBody;
	public final fun getBodyDelayNanos ()J
	public final fun getCode ()I
	public final fun getDoNotReadRequestBody ()Z

    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,

      when (expected) {
        is SSLProtocolException -> {
          // RI response to the FAIL_HANDSHAKE
        }

        is SSLHandshakeException -> {
          // Android's response to the FAIL_HANDSHAKE
        }

        is SSLException -> {
          // JDK 1.9 response to the FAIL_HANDSHAKE
          // javax.net.ssl.SSLException: Unexpected handshake message: client_hello
        }

      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,
        ),

      if (!processTunnelRequests()) return

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