}

    internal constructor(mockResponse: MockResponse) {
      this.inTunnel = mockResponse.inTunnel
      this.informationalResponses_ = mockResponse.informationalResponses.toMutableList()
      this.status = mockResponse.status
      this.headers_ = mockResponse.headers.newBuilder()
      this.trailers_ = mockResponse.trailers.newBuilder()
      this.bodyVar = mockResponse.body

  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(

	public final fun addHeaderLenient (Ljava/lang/String;Ljava/lang/Object;)Lmockwebserver3/MockResponse$Builder;
	public final fun addInformationalResponse (Lmockwebserver3/MockResponse;)Lmockwebserver3/MockResponse$Builder;
	public final fun addPush (Lmockwebserver3/PushPromise;)Lmockwebserver3/MockResponse$Builder;
	public final fun body (Ljava/lang/String;)Lmockwebserver3/MockResponse$Builder;

  @Test
  fun connectionsAreReused() {
    server.enqueue(MockResponse(body = "a"))
    server.enqueue(MockResponse(body = "b"))
    val request = Request(server.url("/"))
    assertConnectionReused(request, request)
  }

  @Test
  fun connectionsAreReusedForPosts() {
    server.enqueue(MockResponse(body = "a"))
    server.enqueue(MockResponse(body = "b"))
    val request =
      Request(

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

    val mockResponse1 = MockResponse.Builder()
    transferKind.setBody(mockResponse1, "ABCDEFGHIJK", 1024)
    server.enqueue(mockResponse1.build())
    val mockResponse2 = MockResponse.Builder()
    transferKind.setBody(mockResponse2, "LMNOPQRSTUV", 1024)
    server.enqueue(mockResponse2.build())
    val call1 = client.newCall(newRequest("/"))

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

      .isEqualTo("INFO: Callback failure for call to " + server.url("/") + "...")
  }

  @Test
  fun connectionPooling() {
    server.enqueue(MockResponse(body = "abc"))
    server.enqueue(MockResponse(body = "def"))
    server.enqueue(MockResponse(body = "ghi"))
    executeSynchronously("/a").assertBody("abc")
    executeSynchronously("/b").assertBody("def")
    executeSynchronously("/c").assertBody("ghi")

  fun recoverFromConnectionNoNewStreamsOnFollowUp() {
    server.enqueue(MockResponse(code = 401))
    server.enqueue(
      MockResponse
        .Builder()
        .onRequestStart(CloseStream(ErrorCode.INTERNAL_ERROR.httpCode))
        .build(),
    )
    server.enqueue(MockResponse(body = "DEF"))
    server.enqueue(
      MockResponse(
        code = 301,
        headers = headersOf("Location", "/foo"),

  }

  private fun testServerPrematureDisconnect(transferKind: TransferKind) {
    val mockResponse = MockResponse.Builder()
    transferKind.setBody(mockResponse, "ABCDE\nFGHIJKLMNOPQRSTUVWXYZ", 16)
    server.enqueue(truncateViolently(mockResponse, 16).build())
    server.enqueue(
      MockResponse
        .Builder()
        .body("Request #2")
        .build(),
    )