@Test
  fun serverDisconnectsBeforeSecondRequestHttp1() {
    enableProtocol(Protocol.HTTP_1_1)

    server.enqueue(MockResponse(code = 200, body = "Req1"))
    server.enqueue(MockResponse(code = 200, body = "Req2"))

    val eventListener =
      object : EventListener() {
        var socket: SSLSocket? = null
        var closed = false

      }

      override fun writeTo(sink: BufferedSink) {
        sink.writeUtf8("<element/>")
        sink.flush()
      }
    }

    server.enqueue(MockResponse(code = 201))
    server.enqueue(MockResponse(code = 204))
    server.enqueue(MockResponse(code = 204))

    val endpointUrl = server.url("/endpoint")

    var request =
      Request.Builder()
        .url(endpointUrl)

  ) {
    setUp(protocol, mockWebServer)
    server.enqueue(
      MockResponse.Builder()
        .body(Buffer().write(ByteArray(Http2Connection.OKHTTP_CLIENT_WINDOW_SIZE + 1)))
        .build(),
    )
    server.enqueue(
      MockResponse(body = "abc"),
    )
    // Enqueue an additional response that show if we burnt a good prior response.
    server.enqueue(
      MockResponse(body = "XXX"),
    )

        .build()
    server.enqueue(
      MockResponse.Builder()
        .headersDelay(500, TimeUnit.MILLISECONDS)
        .setHeader("content-type", "text/event-stream")
        .body("data: hey\n\n")
        .build(),
    )
    newEventSource()
    listener.assertFailure("timeout")
  }

  @Test
  fun retainsAccept() {
    server.enqueue(
      MockResponse.Builder()
        .body(

    server!!.enqueue(MockResponse())
    assertSuccessfulEventOrder()
  }

  @Test
  @Throws(IOException::class)
  fun multipleDnsLookupsForSingleCall() {
    server!!.enqueue(
      MockResponse(
        code = 301,
        headers = headersOf("Location", "http://www.fakeurl:" + server!!.port),
      ),
    )
    server!!.enqueue(MockResponse())
    val dns = FakeDns()

    server.enqueue(MockResponse())
    val request =
      Request.Builder()
        .url(server.url("/"))
        .post(sleepingRequestBody(500))
        .build()
    val latch = CountDownLatch(1)
    val exceptionRef = AtomicReference<Throwable>()
    val call = client.newCall(request)
    call.timeout().timeout(250, TimeUnit.MILLISECONDS)
    call.enqueue(
      object : Callback {

  }

  @Test
  fun receiveAndSendMultipleCookies() {
    server.enqueue(
      MockResponse.Builder()
        .addHeader("Set-Cookie", "a=android")
        .addHeader("Set-Cookie", "b=banana")
        .build(),
    )
    server.enqueue(MockResponse())
    val cookieManager = CookieManager(null, CookiePolicy.ACCEPT_ORIGINAL_SERVER)
    client =

  }

  @Disabled("Not actually failing where expected")
  @Test
  fun disconnectAtStart() {
    server.enqueue(
      MockResponse.Builder()
        .socketPolicy(DisconnectAtStart)
        .build(),
    )
    server.enqueue(MockResponse()) // The jdk's HttpUrlConnection is a bastard.
    server.enqueue(MockResponse())
    try {
      server.url("/a").toUrl().openConnection().getInputStream()
      fail<Unit>()

        .requestIOException()
        .exhaustResponse()
    server.enqueue(
      MockResponse.Builder()
        .clearHeaders()
        .code(HttpURLConnection.HTTP_MOVED_PERM)
        .addHeader("Location: /b")
        .streamHandler(body)
        .build(),
    )
    server.enqueue(
      MockResponse.Builder()
        .body("this is /b")
        .build(),
    )

  }

  @Disabled("Not actually failing where expected")
  @Test
  fun disconnectAtStart() {
    server.enqueue(
      MockResponse()
        .setSocketPolicy(SocketPolicy.DISCONNECT_AT_START),
    )
    server.enqueue(MockResponse()) // The jdk's HttpUrlConnection is a bastard.
    server.enqueue(MockResponse())
    try {
      server.url("/a").toUrl().openConnection().getInputStream()
      fail<Any>()