"loc": ["query", "token"],
                "msg": "Field required",
                "input": None,
            },
            {
                "type": "missing",
                "loc": ["header", "x-token"],
                "msg": "Field required",
                "input": None,
            },
        ]
    }


def test_put_invalid_header(client: TestClient):

from fastapi import FastAPI, File
from fastapi.testclient import TestClient

app = FastAPI()


@app.post("/files")
async def upload_files(files: list[bytes] | None = File(None)):
    if files is None:
        return {"files_count": 0}
    return {"files_count": len(files), "sizes": [len(f) for f in files]}


def test_optional_bytes_list():
    client = TestClient(app)
    response = client.post(
        "/files",

 * {@link #at}, {@link #set}, {@link #toArray}, {@link #rowKeyList}, and {@link #columnKeyList}
 * methods for more details.
 *
 * <p>Note that this implementation is not synchronized. If multiple threads access the same cell of
 * an {@code ArrayTable} concurrently and one of the threads modifies its value, there is no
 * guarantee that the new value will be fully visible to the other threads. To guarantee that

			c := s[hi]
			if c >= utf8.RuneSelf {
				return TrimFunc(s[:hi+1], unicode.IsSpace)
			}
			if asciiSpace[c] == 0 {
				// At this point, s[:hi+1] starts and ends with ASCII
				// non-space bytes, so we're done. Non-ASCII cases have
				// already been handled above.
				return s[:hi+1]
			}
		}
	}
	// Special case to preserve previous TrimLeftFunc behavior,

app = FastAPI()


@app.get("/items/")
def read_items(q: str | None = Param(default=None)):  # type: ignore
    return {"q": q}


client = TestClient(app)


def test_default_param_query_none():
    response = client.get("/items/")
    assert response.status_code == 200, response.text
    assert response.json() == {"q": None}


def test_default_param_query():
    response = client.get("/items/?q=foo")

    assert response.json() == {
        "detail": [
            {
                "type": "missing",
                "loc": ["query", "query"],
                "msg": "Field required",
                "input": None,
            }
        ]
    }


def test_query_query_baz():
    response = client.get("/query?query=baz")
    assert response.status_code == 200
    assert response.json() == "foo bar baz"

from fastapi.encoders import jsonable_encoder
from fastapi.responses import JSONResponse
from pydantic import BaseModel


class Item(BaseModel):
    title: str
    timestamp: datetime
    description: str | None = None


app = FastAPI()


@app.put("/items/{id}")
def update_item(id: str, item: Item):
    json_compatible_item_data = jsonable_encoder(item)

HSPLokhttp3/internal/http2/Http2Writer;->headers(ZILjava/util/List;)V
HSPLokhttp3/internal/http2/Http2Writer;->windowUpdate(IJ)V
HSPLokhttp3/internal/http2/Huffman$Node;-><init>()V
HSPLokhttp3/internal/http2/Huffman$Node;-><init>(II)V
HSPLokhttp3/internal/http2/Huffman;-><clinit>()V
HSPLokhttp3/internal/http2/Huffman;-><init>()V
HSPLokhttp3/internal/http2/Huffman;->addCode(III)V

/// note | Nota

FastAPI sabrá que el valor de `q` no es requerido debido al valor por defecto `= None`.

El `str | None` no es utilizado por FastAPI para determinar que el valor no es requerido, sabrá que no es requerido porque tiene un valor por defecto de `= None`.

            "price": 50.5,
            "description": None,
            "tax": None,
        },
    }


def test_post_no_body(client: TestClient):
    response = client.put("/items/5", json=None)
    assert response.status_code == 422
    assert response.json() == {
        "detail": [
            {
                "input": None,
                "loc": [
                    "body",