/// warning | Achtung

Sie können mehrere `File`- und `Form`-Parameter in einer *Pfadoperation* deklarieren, aber Sie können nicht gleichzeitig auch `Body`-Felder deklarieren, welche Sie als JSON erwarten, da der Request den Body mittels `multipart/form-data` statt `application/json` kodiert.

Das ist keine Limitation von **FastAPI**, sondern Teil des HTTP-Protokolls.

///

## Zusammenfassung

    assertFailsWith<IOException> {
      response.body.source().readUtf8()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("timeout")
      assertThat(call.isCanceled()).isTrue()
    }
  }

  @Test
  fun timeoutReadingResponseWithEnqueue() {
    server.enqueue(
      MockResponse
        .Builder()
        .body(BIG_ENOUGH_BODY)
        .build(),
    )
    val request =

      closed = true
      currentPart = null
      source.close()
    }

    /** A single part in a multipart body. */
    class Part(
      @get:JvmName("headers") val headers: Headers,
      @get:JvmName("body") val body: BufferedSource,
    ) : Closeable by body

    internal companion object {
      /** These options follow the boundary. */
      val afterBoundaryOptions =
        Options.of(

    if (!response.promisesBody()) {
      return response
    }
    val body = response.body
    val encoding = response.header("Content-Encoding") ?: return response

    val algorithm = lookupDecompressor(encoding) ?: return response

    val decompressedSource = algorithm.decompress(body.source()).buffer()

    return response
      .newBuilder()
      .removeHeader("Content-Encoding")

        ).protocol(Protocol.HTTP_1_1)
        .code(200)
        .message("OK")
        .build()
    assertThat(response.body.contentType()).isNull()
    assertThat(response.body.contentLength()).isEqualTo(0L)
    assertThat(response.body.byteString()).isEqualTo(EMPTY)
  }

  /**
   * Returns a new response body that refuses to be read once it has been closed. This is true of
   * most [BufferedSource] instances, but not of [Buffer].
   */

/// warning

You can declare multiple `File` and `Form` parameters in a *path operation*, but you can't also declare `Body` fields that you expect to receive as JSON, as the request will have the body encoded using `multipart/form-data` instead of `application/json`.

This is not a limitation of **FastAPI**, it's part of the HTTP protocol.

///

## Recap { #recap }

class ResponseBodyJvmTest {
  @Test
  fun stringEmpty() {
    val body = body("")
    assertThat(body.string()).isEqualTo("")
  }

  @Test
  fun stringLooksLikeBomButTooShort() {
    val body = body("000048")
    assertThat(body.string()).isEqualTo("\u0000\u0000H")
  }

  @Test
  fun stringDefaultsToUtf8() {
    val body = body("68656c6c6f")
    assertThat(body.string()).isEqualTo("hello")
  }

  @Test

Pero debido a nuestros cambios en `GzipRequest.body`, el request body se descomprimirá automáticamente cuando sea cargado por **FastAPI** si es necesario.

## Accediendo al request body en un manejador de excepciones

/// tip | Consejo

  @Throws(IOException::class)
  fun non101RetainsBody() {
    webServer.enqueue(
      MockResponse
        .Builder()
        .code(200)
        .body("Body")
        .build(),
    )
    newWebSocket()
    clientListener.assertFailure(
      200,
      "Body",
      ProtocolException::class.java,
      "Expected HTTP 101 response but was '200 OK'",
    )
  }

  @Test
  @Throws(IOException::class)

      it.write(this@gzipCompress)
    }
    return result.readByteString()
  }

  private fun response(
    url: String,
    body: ByteString,
    fn: Response.Builder.() -> Unit = {},
  ): Response =
    Response
      .Builder()
      .body(body.toResponseBody("text/plain".toMediaType()))
      .code(200)
      .message("OK")
      .request(Request.Builder().url(url).build())