val pushPromises: List<PushPromise>
    get() = promises

  init {
    setResponseCode(200)
    setHeader("Content-Length", 0L)
  }

  public override fun clone(): MockResponse {
    val result = super.clone() as MockResponse
    result.headersBuilder = headersBuilder.build().newBuilder()
    result.promises = promises.toMutableList()
    return result
  }

  @JvmName("-deprecated_getStatus")
  @Deprecated(

        when(mockResponse.getGrantedCredits()).thenReturn(100);
        assertEquals(100, mockResponse.getGrantedCredits());

        // Verify the method was called
        verify(mockResponse, times(1)).getGrantedCredits();
    }

    @Test
    void testGetErrorCode() {
        // Simulate error code
        when(mockResponse.getErrorCode()).thenReturn(-1);
        assertEquals(-1, mockResponse.getErrorCode());

    var trailers: Headers = mockResponse.trailers
    mockResponse = mockResponse.clearHeaders()
    mockResponse = mockResponse.addHeader("")
    mockResponse = mockResponse.addHeader("", "")
    mockResponse = mockResponse.addHeaderLenient("", Any())
    mockResponse = mockResponse.setHeader("", Any())
    mockResponse.headers = headersOf()
    mockResponse.trailers = headersOf()

 * [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(

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

      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)

    val mockResponse =
      MockResponse
        .Builder()
        .doNotReadRequestBody()
        .trailers(headersOf("caboose", "xyz"))

    // Trailers always work for HTTP/2, but only for chunked bodies in HTTP/1.
    if (http2) {
      mockResponse.body("abc")
    } else {
      mockResponse.chunkedBody("abc", 1)
    }

### Kotlin
```kotlin
val response = MockResponse.Builder()
  .addHeader("Content-Type", "application/json; charset=utf-8")
  .addHeader("Cache-Control", "no-cache")
  .body("{}")
  .build()
```

MockResponse can be used to simulate a slow network. This is useful for
testing timeouts and interactive testing.

### Java
```java
MockResponse response = new MockResponse.Builder()

import assertk.assertions.hasMessage
import assertk.assertions.isEqualTo
import assertk.assertions.isNull
import assertk.assertions.isTrue
import kotlin.test.assertFailsWith
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.junit5.StartStop
import okhttp3.Headers.Companion.headersOf
import okhttp3.OkHttpClientTestRule
import okhttp3.Protocol
import okhttp3.RecordingEventListener