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

app = FastAPI()


@app.post("/form/python-list")
def post_form_param_list(items: list = Form()):
    return items


@app.post("/form/python-set")
def post_form_param_set(items: set = Form()):
    return items


@app.post("/form/python-tuple")
def post_form_param_tuple(items: tuple = Form()):
    return items


client = TestClient(app)

    bus.register(recorder);

    bus.post(FIRST);

    assertEquals(
        "EventRecorder expected events in order",
        Lists.<Object>newArrayList(FIRST, SECOND),
        recorder.eventsReceived);
  }

  public final class EventProcessor {
    @Subscribe
    public void listenForStrings(String event) {
      bus.post(SECOND);
    }
  }

  static final class EventRecorder {

    pass


app = FastAPI()


@app.post("/")
async def post(
    foo: Foo | None = None,
):
    return foo


client = TestClient(app)


def test_call_invalid():
    response = client.post("/", json={"foo": {"bar": "baz"}})
    assert response.status_code == 422


def test_call_valid():
    response = client.post("/", json={})
    assert response.status_code == 200

app = FastAPI()


@app.post("/file_before_form")
def file_before_form(
    file: bytes = File(),
    city: str = Form(),
):
    return {"file_content": file, "city": city}


@app.post("/file_after_form")
def file_after_form(
    city: str = Form(),
    file: bytes = File(),
):
    return {"file_content": file, "city": city}


@app.post("/file_list_before_form")
def file_list_before_form(

    client = TestClient(mod.app)
    return client


@pytest.mark.parametrize("price", ["50.5", 50.5])
def test_post_with_tax(client: TestClient, price: str | float):
    response = client.post(
        "/items/",
        json={"name": "Foo", "price": price, "description": "Some Foo", "tax": 0.3},
    )
    assert response.status_code == 200
    assert response.json() == {
        "name": "Foo",

    ]
    response = client.post("/images/multiple", json=data)
    assert response.status_code == 200, response.text
    assert response.json() == data


def test_post_invalid_list_item(client: TestClient):
    data = [{"url": "not a valid url", "name": "Example"}]
    response = client.post("/images/multiple", json=data)
    assert response.status_code == 422, response.text

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",

   * HTTP connections when connection reuse is in practice.
   */
  public val requestCount: Int
    get() = atomicRequestCount.get()

  /** The number of bytes of the POST body to keep in memory to the given limit. */
  public var bodyLimit: Long = Long.MAX_VALUE

  public var serverSocketFactory: ServerSocketFactory?
    @Synchronized get() = serverSocketFactory_

from typing import Annotated

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

app = FastAPI()


@app.post("/urlencoded")
async def post_url_encoded(age: Annotated[int | None, Form()] = None):
    return age


@app.post("/multipart")
async def post_multi_part(
    age: Annotated[int | None, Form()] = None,
    file: Annotated[bytes | None, File()] = None,
):

        @app.post("/union")
        def endpoint(data: dict | ModelV1A):  # pragma: no cover
            return data


def test_raises_pydantic_v1_model_in_sequence() -> None:
    class ModelV1A(BaseModel):
        name: str

    app = FastAPI()

    with pytest.raises(PydanticV1NotSupportedError):

        @app.post("/sequence")