.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(
          """

import assertk.assertions.isEqualTo
import assertk.assertions.isNotNull
import assertk.assertions.isNull
import javax.net.ssl.SSLException
import kotlin.test.assertFailsWith
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import okhttp3.testing.PlatformRule
import okhttp3.tls.HandshakeCertificates
import okhttp3.tls.HeldCertificate
import org.junit.jupiter.api.BeforeEach

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

 */
package okhttp3.mockwebserver

abstract class Dispatcher {
  @Throws(InterruptedException::class)
  abstract fun dispatch(request: RecordedRequest): MockResponse

  open fun peek(): MockResponse {
    return MockResponse().apply { this.socketPolicy = SocketPolicy.KEEP_OPEN }
  }

  open fun shutdown() {}

    }
    response.append("</body></html>");

    return new MockResponse()
        .setStatus("HTTP/1.1 200")
        .addHeader("content-type: text/html; charset=utf-8")
        .setBody(response.toString());
  }

  private MockResponse fileToResponse(String path, File file) throws IOException {
    return new MockResponse()
        .setStatus("HTTP/1.1 200")
        .setBody(fileToBytes(file))

        )
        .build()

    // Set up a same-connection retry.
    serverIpv4.enqueue(
      MockResponse(socketPolicy = ResetStreamAtStart(ErrorCode.REFUSED_STREAM.httpCode)),
    )
    serverIpv4.enqueue(
      MockResponse(body = "this was the 2nd request on IPv4"),
    )
    serverIpv6.enqueue(
      MockResponse(body = "unexpected call to IPv6"),
    )

    // Confirm the retry succeeds on the same connection.

	public final fun setHeader (Ljava/lang/String;Ljava/lang/Object;)Lokhttp3/mockwebserver/MockResponse;
	public final fun setHeaders (Lokhttp3/Headers;)Lokhttp3/mockwebserver/MockResponse;
	public final fun setHeadersDelay (JLjava/util/concurrent/TimeUnit;)Lokhttp3/mockwebserver/MockResponse;
	public final fun setHttp2ErrorCode (I)Lokhttp3/mockwebserver/MockResponse;
	public final fun setResponseCode (I)Lokhttp3/mockwebserver/MockResponse;

    this.server = server
    socksProxy.play()
  }

  @AfterEach
  fun tearDown() {
    socksProxy.shutdown()
  }

  @Test
  fun proxy() {
    server.enqueue(MockResponse.Builder().body("abc").build())
    server.enqueue(MockResponse.Builder().body("def").build())
    val client =
      clientTestRule.newClientBuilder()
        .proxy(socksProxy.proxy())
        .build()

   */
  @Test
  fun unauthorizedResponseHandling() {
    val mockResponse =
      MockResponse(
        code = HttpURLConnection.HTTP_UNAUTHORIZED,
        headers = headersOf("WWW-Authenticate", "challenge"),
        body = "Unauthorized",
      )
    server.enqueue(mockResponse)
    server.enqueue(mockResponse)
    server.enqueue(mockResponse)
    val response = getResponse(newRequest("/"))

  @Test
  fun misdirectedRequestResponseCode() {
    server.enqueue(
      MockResponse.Builder()
        .body("seed connection")
        .build(),
    )
    server.enqueue(
      MockResponse.Builder()
        .code(421)
        .body("misdirected!")
        .build(),
    )
    server.enqueue(
      MockResponse.Builder()
        .body("after misdirect")
        .build(),
    )