}
	extractedSignedHeaders := make(http.Header)
	for _, header := range signedHeaders {
		// `host` will not be found in the headers, can be found in r.Host.
		// but its always necessary that the list of signed headers containing host in it.
		val, ok := reqHeaders[http.CanonicalHeaderKey(header)]
		if !ok {
			// try to set headers from Query String
			val, ok = reqQueries[header]
		}
		if ok {

    /**
     * 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;

    /**

// The Header.Size determines how many bytes can be written for the next file.
// If the current file is not fully written, then this returns an error.
// This implicitly flushes any padding necessary before writing the header.
func (tw *Writer) WriteHeader(hdr *Header) error {
	if err := tw.Flush(); err != nil {
		return err
	}
	tw.hdr = *hdr // Shallow copy of Header

# Header 1 { #header-1 }

Some text with a link to [FastAPI](https://fastapi.tiangolo.com).

## Header 2 { #header-2 }

Two links here: [How to](https://fastapi.tiangolo.com/how-to/) and [Project Generators](project-generation.md){.internal-link target=_blank}.

### Header 3 { #header-3 }

Another link: [**FastAPI** Project Generators](project-generation.md "Link title"){.internal-link target=_blank} with title.

# Header 4 { #header-4 }

	defer func(flag bool) { globalIsTLS = flag }(globalIsTLS)
	globalIsTLS = true
	for i, test := range encryptRequestTests {
		content := bytes.NewReader(make([]byte, 64))
		req := &http.Request{Header: http.Header{}}
		for k, v := range test.header {
			req.Header.Set(k, v)
		}
		_, _, err := EncryptRequest(content, req, "bucket", "object", test.metadata)
		if err != nil {
			t.Fatalf("Test %d: Failed to encrypt request: %v", i, err)
		}

                                    "Header One": {
                                        "summary": "Header One Summary",
                                        "description": "Header One Description",
                                        "value": "header1",
                                    },
                                    "Header Two": {"value": "header2"},
                                },

@app.get("/header-json-list")
def header_json_list(x_items: Annotated[Json[list[str]], Header()]) -> list[str]:
    return x_items


@app.get("/cookie-json-list")
def cookie_json_list(items: Annotated[Json[list[str]], Cookie()]) -> list[str]:
    return items


client = TestClient(app)


def test_form_json_list():
    response = client.post(
        "/form-json-list", data={"items": json.dumps(["abc", "def"])}
    )

        assertArrayEquals(testData, response.getData());
        // The decode method returns only the header size (16 bytes)\n        assertEquals(16, bytesDecoded);
    }

    @Test
    @DisplayName("Test decode without data")
    void testDecodeWithoutData() throws SMBProtocolDecodingException {
        // Prepare test data - only header, no data
        byte[] buffer = new byte[16];
        int bufferIndex = 0;

	if proto := r.Header.Get(xForwardedProto); proto != "" {
		scheme = strings.ToLower(proto)
	} else if proto = r.Header.Get(xForwardedScheme); proto != "" {
		scheme = strings.ToLower(proto)
	} else if proto := r.Header.Get(forwarded); proto != "" {
		// match should contain at least two elements if the protocol was
		// specified in the Forwarded header. The first element will always be

    assert fixed_content == expected_content  # Translated doc remains unchanged
    assert "Error processing docs/lang/docs/doc.md" in result.output
    assert (
        "Header levels do not match between document and original document"
        " (found #, expected ##) for header №2 in line 5"
    ) in result.output


@pytest.mark.parametrize(
    "copy_test_files",