closeSocket = false,
          shutdownOutput = true,
        ),
      )
    SocketPolicy.STALL_SOCKET_AT_START -> result.onRequestStart(SocketEffect.Stall)
    SocketPolicy.NO_RESPONSE -> result.onResponseStart(SocketEffect.Stall)
    SocketPolicy.RESET_STREAM_AT_START -> result.onRequestStart(CloseStream(http2ErrorCode))
  }

  result.throttleBody(throttleBytesPerPeriod, getThrottlePeriod(MILLISECONDS), MILLISECONDS)

        .setHeader("Sec-WebSocket-Accept", "ujmZX4KXZqjwy6vi1aQFH5p4Ygk=")
        .build(),
    )
    webServer.enqueue(
      MockResponse
        .Builder()
        .onRequestStart(CloseSocket())
        .build(),
    )
    val webSocket = newWebSocket()
    clientListener.assertFailure(
      101,
      null,
      ProtocolException::class.java,

    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
    this.onResponseBody = builder.onResponseBody

      MockResponse
        .Builder()
        .onRequestStart(CloseStream(ErrorCode.REFUSED_STREAM.httpCode))
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .onRequestStart(CloseStream(ErrorCode.REFUSED_STREAM.httpCode))
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .onRequestStart(CloseStream(ErrorCode.REFUSED_STREAM.httpCode))

  /** Confirm suppressed exceptions that occur after connecting are returned. */
  @Test fun httpExceptionsAreReturnedAsSuppressed() {
    server.enqueue(MockResponse.Builder().onRequestStart(CloseSocket()).build())
    server.enqueue(MockResponse.Builder().onRequestStart(CloseSocket()).build())

    client =
      client
        .newBuilder()
        .dns(DoubleInetAddressDns()) // Two routes so we get two failures.
        .build()

            }
          },
        ).build()

    // Set up a same-connection retry.
    serverIpv4.enqueue(
      MockResponse
        .Builder()
        .onRequestStart(CloseStream(ErrorCode.REFUSED_STREAM.httpCode))
        .build(),
    )
    serverIpv4.enqueue(
      MockResponse(body = "this was the 2nd request on IPv4"),
    )
    serverIpv6.enqueue(

      } catch (e: SocketException) {
        logger.fine("${this@MockWebServer} done accepting connections: ${e.message}")
        return
      }

      val peek = dispatcher.peek()
      if (peek.onRequestStart is CloseSocket) {
        dispatchBookkeepingRequest(
          connectionIndex = nextConnectionIndex++,
          exchangeIndex = 0,
          socket = MockWebServerSocket(socket),
        )

  val dns = FakeDns()

  val ipv4 = InetAddress.getByName("203.0.113.1")
  val ipv6 = InetAddress.getByName("2001:db8:ffff:ffff:ffff:ffff:ffff:1")

  val refusedStream =
    MockResponse
      .Builder()
      .onRequestStart(CloseStream(ErrorCode.REFUSED_STREAM.httpCode))
      .build()
  val bodyResponse = MockResponse(body = "body")

  @BeforeEach
  fun setUp() {

	public final fun inTunnel ()Lmockwebserver3/MockResponse$Builder;
	public final fun onRequestBody (Lmockwebserver3/SocketEffect;)Lmockwebserver3/MockResponse$Builder;
	public final fun onRequestStart (Lmockwebserver3/SocketEffect;)Lmockwebserver3/MockResponse$Builder;
	public final fun onResponseBody (Lmockwebserver3/SocketEffect;)Lmockwebserver3/MockResponse$Builder;

  }

  @Disabled("Not actually failing where expected")
  @Test
  fun disconnectAtStart() {
    server.enqueue(
      MockResponse
        .Builder()
        .onRequestStart(CloseSocket())
        .build(),
    )
    server.enqueue(MockResponse()) // The jdk's HttpUrlConnection is a bastard.
    server.enqueue(MockResponse())
    try {
      server
        .url("/a")