// Both should create valid responses
            Smb2EchoResponse response1 = request1.createResponse(mockContext, request1);
            Smb2EchoResponse response2 = request2.createResponse(mockContext, request2);

            assertNotNull(response1);
            assertNotNull(response2);
            assertNotSame(response1, response2);
        }
    }

    @Nested

            response.readBytesWireFormat(buffer1, 0);
            assertEquals(1024, response.getCount());
            assertEquals(512, response.getRemaining());

            // Second read - should update values
            byte[] buffer2 = createValidWriteResponse(2048, 1024);
            response.readBytesWireFormat(buffer2, 0);
            assertEquals(2048, response.getCount());

👉 🙅 💼 🍵 🔁 FastAPI ↩️ 📨 🆎 ✍ 🎓 (⚖️ 🏿) `Response`.

& 🧰 🔜 😄 ↩️ 👯‍♂️ `RedirectResponse` & `JSONResponse` 🏿 `Response`, 🆎 ✍ ☑.

### ✍ 📨 🏿

👆 💪 ⚙️ 🏿 `Response` 🆎 ✍:

{* ../../docs_src/response_model/tutorial003_03.py hl[8:9] *}

👉 🔜 👷 ↩️ `RedirectResponse` 🏿 `Response`, & FastAPI 🔜 🔁 🍵 👉 🙅 💼.

### ❌ 📨 🆎 ✍

### Anotar uma subclasse de resposta

Você também pode usar uma subclasse de `Response` na anotação de tipo:

{* ../../docs_src/response_model/tutorial003_03.py hl[8:9] *}

Isso também funcionará porque `RedirectResponse` é uma subclasse de `Response`, e o FastAPI tratará automaticamente este caso simples.

### Anotações de Tipo de Retorno Inválido

    }

    String response2Body;
    try (Response response2 = client.newCall(request).execute()) {
      if (!response2.isSuccessful()) throw new IOException("Unexpected code " + response2);

      response2Body = response2.body().string();
      System.out.println("Response 2 response:          " + response2);
      System.out.println("Response 2 cache response:    " + response2.cacheResponse());

	// execute the http request to fetch object.
	response, err = s.client.Do(request)
	c.Assert(err, nil)
	// assert the http response status code.
	c.Assert(response.StatusCode, http.StatusOK)

	var buffer bytes.Buffer
	// extract the body of the response.
	responseBody, err := io.ReadAll(response.Body)
	c.Assert(err, nil)
	// assert the http response body content.

          .build(),
      )
    var response = call.execute()
    assertThat(response.code).isEqualTo(200)
    assertThat(response.body.string()).isEqualTo("abc")
    response.close()
    listener.clearAllEvents()
    call = call.clone()
    response = call.execute()
    assertThat(response.code).isEqualTo(200)
    assertThat(response.body.string()).isEqualTo("abc")
    response.close()

        .build()
    val request1 = Request.Builder().url(server.url("/")).build()
    val response1 = client.newCall(request1).execute()
    assertThat(response1.body.string()).isEqualTo("abc")
    val request2 = Request.Builder().url(server.url("/")).build()
    val response2 = client.newCall(request2).execute()
    assertThat(response2.body.string()).isEqualTo("def")

    // The HTTP calls should share a single connection.

      val code = response.code
      if (code != HTTP_TEMP_REDIRECT && code != HTTP_PERM_REDIRECT) return response
      val method = response.request.method
      if (method == "GET" || method == "HEAD") return response
      val location = response.header("Location") ?: return response
      return response
        .newBuilder()
        .removeHeader("Location")
        .header("LegacyRedirectInterceptor-Location", location)

* `expose_headers` - Indica cualquier header de response que debería ser accesible para el navegador. Por defecto es `[]`.
* `max_age` - Establece un tiempo máximo en segundos para que los navegadores almacenen en caché los responses CORS. Por defecto es `600`.

El middleware responde a dos tipos particulares de request HTTP...

### Requests de preflight CORS