webServer.enqueue(
      MockResponse
        .Builder()
        .code(408)
        .build(),
    )
    webServer.enqueue(
      MockResponse
        .Builder()
        .webSocketUpgrade(serverListener)
        .build(),
    )
    val webSocket: WebSocket = newWebSocket()
    clientListener.assertOpen()
    val server = serverListener.assertOpen()
    webSocket.send("abc")

  }

  @Test
  fun secondCallEventSequence() {
    enableTlsWithTunnel()
    server.protocols = Arrays.asList(Protocol.HTTP_2, Protocol.HTTP_1_1)
    server.enqueue(MockResponse())
    server.enqueue(MockResponse())
    client
      .newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      ).execute()
      .close()

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

 * [enqueue].
 */
public open class QueueDispatcher : Dispatcher() {
  protected val responseQueue: BlockingQueue<MockResponse> = LinkedBlockingQueue()
  private var failFastResponse: MockResponse? = null

  @Throws(InterruptedException::class)
  override fun dispatch(request: RecordedRequest): MockResponse {
    // To permit interactive/browser testing, ignore requests for favicons.
    val requestLine = request.requestLine

    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(

    // 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(
      MockResponse(body = "unexpected call to IPv6"),
    )

  }

  @Test
  fun singleTimeoutForAllFollowUpRequests() {
    server.enqueue(
      MockResponse
        .Builder()
        .code(HttpURLConnection.HTTP_MOVED_TEMP)
        .setHeader("Location", "/b")
        .headersDelay(100, TimeUnit.MILLISECONDS)
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .code(HttpURLConnection.HTTP_MOVED_TEMP)

    private TestHttpServletResponse mockResponse;
    private TestFilterChain mockFilterChain;

    @Override
    public void setUp() throws Exception {
        super.setUp();
        corsFilter = new CorsFilter();
        corsHandlerFactory = new TestCorsHandlerFactory();
        // Initialize mocks
        mockRequest = new TestHttpServletRequest();
        mockResponse = new TestHttpServletResponse();

import kotlin.concurrent.thread
import kotlin.test.assertFailsWith
import kotlin.time.Duration
import kotlin.time.Duration.Companion.milliseconds
import kotlin.time.measureTime
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.SocketEffect.CloseSocket
import mockwebserver3.SocketEffect.ShutdownConnection
import mockwebserver3.junit5.StartStop
import okhttp3.Headers.Companion.headersOf

      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)