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> {

    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

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