i, o, l, skip, sn, ps, oRef, lRef, skipRef, snRef, psRef)
			}
		}
	}
}

var getDefaultOptsTests = []struct {
	headers        http.Header
	copySource     bool
	metadata       map[string]string
	encryptionType encrypt.Type
	err            error
}{
	{
		headers: http.Header{
			xhttp.AmzServerSideEncryptionCustomerAlgorithm: []string{"AES256"},

**FastAPI** will use that *temporal* response to extract the cookies (also headers and status code), and will put them in the final response that contains the value you returned, filtered by any `response_model`.

You can also declare the `Response` parameter in dependencies, and set cookies (and headers) in them.

## Return a `Response` directly { #return-a-response-directly }

    assertThat(request.headers[":scheme"]).isEqualTo(scheme)
    assertThat(request.headers[":authority"]).isEqualTo(
      server.hostName + ":" + server.port,
    )
    val pushedRequest = server.takeRequest()
    assertThat(pushedRequest.requestLine).isEqualTo("GET /foo/bar HTTP/2")
    assertThat(pushedRequest.headers["foo"]).isEqualTo("bar")
  }

  @ParameterizedTest

}
```

### Rewriting Responses

Symmetrically, interceptors can rewrite response headers and transform the response body. This is generally more dangerous than rewriting request headers because it may violate the webserver's expectations!

    return out
  }

  private fun sendHeaderFrames(
    outFinished: Boolean,
    headers: List<Header>,
  ): Buffer {
    val out = Buffer()
    Http2Writer(out, true).headers(outFinished, expectedStreamId, headers)
    return out
  }

  private fun sendPushPromiseFrames(
    streamId: Int,
    headers: List<Header>,
  ): Buffer {
    val out = Buffer()

    client.listener.assertTextMessage(message)
  }

  @Test
  fun messagesCompressedWhenConfigured() {
    val headers = headersOf("Sec-WebSocket-Extensions", "permessage-deflate")
    client.initWebSocket(random, responseHeaders = headers)
    server.initWebSocket(random, responseHeaders = headers)
    val message = repeat('a', RealWebSocket.DEFAULT_MINIMUM_DEFLATE_SIZE.toInt())
    server.webSocket!!.send(message)

	}

	// Since the list of signed headers value contained `expect`, the default value of `100-continue` will be added to extracted signed headers.
	if extractedExpect != expectedExpect {
		t.Errorf("expect header incorrect value: expected `%s`, got `%s`", expectedExpect, extractedExpect)
	}

	// case where the headers don't contain the one of the signed header in the signed headers list.

              println("onResponseStarted ${info.headers.asMap} ${info.negotiatedProtocol}")
              request.read(ByteBuffer.allocateDirect(4096 * 8))
            }

            override fun onReadCompleted(
              request: UrlRequest,
              info: UrlResponseInfo,
              byteBuffer: ByteBuffer,
            ) {
              println("onReadCompleted ${info.headers.asMap}")
              byteBuffer.flip()

     */
    protected static final String ACCESS_CONTROL_ALLOW_ORIGIN = "Access-Control-Allow-Origin";

    /**
     * CORS header for specifying allowed headers.
     */
    protected static final String ACCESS_CONTROL_ALLOW_HEADERS = "Access-Control-Allow-Headers";

    /**
     * CORS header for specifying allowed HTTP methods.
     */

///

## Adicione headers customizados

Há certas situações em que é bastante útil poder adicionar headers customizados no HTTP error. Exemplo disso seria adicionar headers customizados para tipos de segurança.

Você provavelmente não precisará utilizar esses headers diretamente no seu código.

Mas caso você precise, para um cenário mais complexo, você pode adicionar headers customizados: