var headers: Headers = mockResponse.headers
    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()

    /**
     * The unique identifier of the request header.
     */
    public String id;

    /**
     * The name of the request header.
     */
    public String name;

    /**
     * The value of the request header.
     */
    public String value;

    /**
     * The web configuration ID associated with this request header.
     */
    public String webConfigId;

    /**

        .newRequest(server.url("/").toUri())
        .header("Accept", "text/plain")
    val response = request.send()
    assertThat(response.status).isEqualTo(200)
    assertThat(response.contentAsString).isEqualTo("hello, Jetty HTTP Client")

    val recorded = server.takeRequest()
    assertThat(recorded.headers["Accept"]).isEqualTo("text/plain")
    assertThat(recorded.headers["Accept-Encoding"]).isEqualTo("gzip")

* `content` - A `str` or `bytes`.
* `status_code` - An `int` HTTP status code.
* `headers` - A `dict` of strings.
* `media_type` - A `str` giving the media type. E.g. `"text/html"`.

FastAPI (actually Starlette) will automatically include a Content-Length header. It will also include a Content-Type header, based on the `media_type` and appending a charset for text types.

  @Test
  fun upgradeRefusedByServer() {
    server.enqueue(MockResponse(body = "normal request"))
    val requestWithUpgrade =
      Request
        .Builder()
        .url(server.url("/"))
        .header("Connection", "upgrade")
        .build()
    client.newCall(requestWithUpgrade).execute().use { response ->
      assertThat(response.code).isEqualTo(200)
      assertThat(response.socket).isNull()

      )
    call1.execute().use { response -> response.body.string() }

    listener.shouldClose = true
    // Large headers are a likely reason the servers would cut off the connection before it completes sending
    // request headers.
    // 431 "Request Header Fields Too Large"
    val largeHeaders =
      Headers
        .Builder()
        .apply {
          repeat(32) {
            add("name-$it", "value-$it-" + "0".repeat(1024))

```java
import org.codelibs.curl.Curl;
import org.codelibs.curl.CurlResponse;

try (CurlResponse response = Curl.get("https://example.com")
                                .param("q", "curl4j")
                                .header("Accept", "application/json")
                                .executeSync()) {
    System.out.println("Status: " + response.getHttpStatusCode());
    System.out.println(response.getContentAsString());
}
```

			// Lambda mock server
			lambdaServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				w.Header().Set(xhttp.AmzRequestRoute, functionID)
				w.Header().Set(xhttp.AmzRequestToken, functionToken)
				w.Header().Set(xhttp.AmzFwdHeaderContentType, contentType)
				w.Header().Set(xhttp.AmzFwdStatus, strconv.Itoa(lambdaStatus))
				w.WriteHeader(lambdaStatus)
				w.Write([]byte(lambdaBody))
			}))

     */
    @JvmField
    val FORCE_CACHE = commonForceCache()

    /**
     * Returns the cache directives of [headers]. This honors both Cache-Control and Pragma headers
     * if they are present.
     */
    @JvmStatic
    fun parse(headers: Headers): CacheControl = commonParse(headers)
  }

**FastAPI** verwendet diese *vorübergehende* Response, um die Cookies (auch Header und Statuscode) zu extrahieren und fügt diese in die endgültige Response ein, die den von Ihnen zurückgegebenen Wert enthält, gefiltert nach einem beliebigen `response_model`.

Sie können den `Response`-Parameter auch in Abhängigkeiten deklarieren und darin Cookies (und Header) setzen.

## Eine `Response` direkt zurückgeben