def format = new SimpleDateFormat('yyyyMMddHHmmssZ')

    def setup() {
        format.timeZone = TimeZone.getTimeZone("UTC")
    }

    def "final release is added to list"() {
        def snapshot = snapshot('4.3')
        def rc = releasedVersion('4.3-rc-1')
        def versions = releasedVersions(snapshot, rc, [])
        def version = new ReleasedVersion('4.2', '20170913122310+0000')

@app.post("/sync/validated", response_model=ItemOut)
def sync_validated(item: ItemIn, dep: Annotated[int, Depends(dep_b)]):
    return ItemOut(name=item.name, value=item.value, dep=dep)


@app.get("/sync/dict-no-response-model")
def sync_dict_no_response_model():
    return {"name": "foo", "value": 123}


@app.get("/sync/dict-with-response-model", response_model=ItemOut)
def sync_dict_with_response_model(

@router_a_a.get("/")
def get_a_a():
    return {"msg": "Hello A A"}


@router_a_a.get("/override", response_class=PlainTextResponse)
def get_a_a_path_override():
    return "Hello A A"


@router_a_b_override.get("/")
def get_a_b():
    return "Hello A B"


@router_a_b_override.get("/override", response_class=HTMLResponse)
def get_a_b_path_override():
    return "Hello A B"


@router_b_override.get("/")
def get_b():

    BinaryCompatibilityRepository repository

    def jApiClassifier = Stub(JApiClass) // represents interfaces, enums and annotations
    def jApiMethod = Stub(JApiMethod)
    def jApiField = Stub(JApiField) // represents fields and enum literals
    def jApiConstructor = Stub(JApiConstructor)
    def incubatingAnnotation = Stub(JApiAnnotation)
    def deprecatedAnnotation = Stub(JApiAnnotation)
    def overrideAnnotation = Stub(JApiAnnotation)

class CallableDependency:
    def __call__(self, value: str) -> str:
        return value


class CallableGenDependency:
    def __call__(self, value: str) -> Generator[str, None, None]:
        yield value


class AsyncCallableDependency:
    async def __call__(self, value: str) -> str:
        return value


class AsyncCallableGenDependency:

from fastapi.testclient import TestClient


def test_response_with_depends_annotated():
    """Response type hint should work with Annotated[Response, Depends(...)]."""
    app = FastAPI()

    def modify_response(response: Response) -> Response:
        response.headers["X-Custom"] = "modified"
        return response

    @app.get("/")
    def endpoint(response: Annotated[Response, Depends(modify_response)]):

    def previousVersions = [
        "1.9.10", "1.9.25", "1.9.24", "1.9.20", "1.9.20-RC2", "1.9.0", "1.9.0-Beta",
        "1.8.22, 1.8.0, 1.8.0-Beta",
    ]
    def minimumSupported = "1.9.10"

    def "latest patch version"() {
        given:
        def allVersions = ["2.0.30", "2.0.20", "2.0.10", "2.0.0"] + previousVersions

        when:

@app.post("/optional-list-str", operation_id="optional_list_str")
async def read_optional_list_str(
    p: Annotated[list[str] | None, Form()] = None,
):
    return {"p": p}


class FormModelOptionalListStr(BaseModel):
    p: list[str] | None = None


@app.post("/model-optional-list-str", operation_id="model_optional_list_str")
async def read_model_optional_list_str(p: Annotated[FormModelOptionalListStr, Form()]):

def get_str_id(item_id: str):
    return item_id


@app.get("/path/int/{item_id}")
def get_int_id(item_id: int):
    return item_id


@app.get("/path/float/{item_id}")
def get_float_id(item_id: float):
    return item_id


@app.get("/path/bool/{item_id}")
def get_bool_id(item_id: bool):
    return item_id


@app.get("/path/param/{item_id}")
def get_path_param_id(item_id: str | None = Path()):

    }

    def "ignores root complete event when tests not finished"() {
        given:
        def delegate = Mock(TestResultProcessor)
        def processor = new RerunTestResultProcessor(delegate);

        def rootDescriptor = descriptor("rootId")
        def rootTestStartEvent = startEvent("rootId")
        def rootCompleteEvent = Mock(TestCompleteEvent)

        def testDescriptor1 = descriptor("testId1")