.receiveRequest("request E\n")
        .sendResponse("response F\n")
        .exhaustRequest()
        .exhaustResponse()
    server.enqueue(
      MockResponse
        .Builder()
        .clearHeaders()
        .socketHandler(body)
        .build(),
    )
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .post(AsyncRequestBody())

    val response =
      MockResponse()
        .clearHeaders()
        .addHeader("Cookie: s=square")
        .addHeader("Cookie", "a=android")
    assertThat(headersToList(response))
      .containsExactly("Cookie: s=square", "Cookie: a=android")
  }

  @Test
  fun mockResponseSetHeader() {
    val response =
      MockResponse()
        .clearHeaders()
        .addHeader("Cookie: s=square")

      MockResponse
        .Builder()
        .clearHeaders()
        .addHeader("Cookie: s=square")
        .addHeader("Cookie", "a=android")
    assertThat(headersToList(builder)).containsExactly("Cookie: s=square", "Cookie: a=android")
  }

  @Test
  fun mockResponseSetHeader() {
    val builder =
      MockResponse
        .Builder()
        .clearHeaders()
        .addHeader("Cookie: s=square")

        in 400..499 -> "Client Error"
        in 500..599 -> "Server Error"
        else -> "Mock Response"
      }
    return apply { status = "HTTP/1.1 $code $reason" }
  }

  fun clearHeaders() =
    apply {
      headersBuilder = Headers.Builder()
    }

  fun addHeader(header: String) =
    apply {
      headersBuilder.add(header)
    }

  fun addHeader(
    name: String,

  }

  @Test
  fun connectionsAreNotReusedWithUnknownLengthResponseBody() {
    server.enqueue(
      MockResponse
        .Builder()
        .body("a")
        .clearHeaders()
        .onResponseEnd(ShutdownConnection)
        .build(),
    )
    server.enqueue(MockResponse(body = "b"))
    val request = Request(server.url("/"))
    assertConnectionNotReused(request, request)

        .clearHeaders()
        .addHeader("Transfer-encoding: chunked")
        .build(),
    )
    getResponse(newRequest("/")).use { response -> assertContent("ABCDE", response) }
  }

  @Test
  fun missingChunkBody() {
    server.enqueue(
      MockResponse
        .Builder()
        .body("5")
        .clearHeaders()

  fun tearDown() {
    cache.close()
    fileSystem.checkNoOpenFiles()
  }

  @Test
  fun get() {
    server.enqueue(
      MockResponse
        .Builder()
        .body("abc")
        .clearHeaders()
        .addHeader("content-type: text/plain")
        .addHeader("content-length", "3")
        .build(),
    )
    val sentAt = System.currentTimeMillis()

        this.status = status
      }

    /**
     * Removes all HTTP headers including any "Content-Length" and "Transfer-encoding" headers that
     * were added by default.
     */
    public fun clearHeaders(): Builder =
      apply {
        headers_ = Headers.Builder()
      }

    /**
     * Adds [header] as an HTTP header. For well-formed HTTP [header] should contain a name followed

	public static synthetic fun chunkedBody$default (Lmockwebserver3/MockResponse$Builder;Lokio/Buffer;IILjava/lang/Object;)Lmockwebserver3/MockResponse$Builder;
	public final fun clearHeaders ()Lmockwebserver3/MockResponse$Builder;
	public synthetic fun clone ()Ljava/lang/Object;
	public fun clone ()Lmockwebserver3/MockResponse$Builder;
	public final fun code (I)Lmockwebserver3/MockResponse$Builder;

        .Builder()
        .body("A")
        .addHeader("Expires: " + formatDate(1, TimeUnit.HOURS))
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .clearHeaders()
        .code(HttpURLConnection.HTTP_NO_CONTENT)
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .body("C")
        .build(),
    )