return field_mapping, definitions  # type: ignore[return-value]

    def is_scalar_field(field: ModelField) -> bool:
        from fastapi import params

        return field_annotation_is_scalar(
            field.field_info.annotation
        ) and not isinstance(field.field_info, params.Body)

    def is_sequence_field(field: ModelField) -> bool:
        return field_annotation_is_sequence(field.field_info.annotation)

        ("/asynchronous-method-gen-dependency", "asynchronous-method-gen-dependency"),
    ],
)
def test_class_dependency(route, value):
    response = client.get(route, params={"value": value})
    assert response.status_code == 200, response.text

+++ b/support/links-dso-program.cc
@@ -3,6 +3,11 @@
    backported.  */
 #define _ISOMAC 1
 
+#define __GLIBC_USE(F)	__GLIBC_USE_ ## F
+
+# define __attribute_alloc_size__(params) \
+  __attribute__ ((__alloc_size__ params))
+
 #include <iostream>
 
 using namespace std;
diff --git a/sysdeps/aarch64/dl-machine.h b/sysdeps/aarch64/dl-machine.h
index 185402f..bbdeae0 100644
--- a/sysdeps/aarch64/dl-machine.h

            final Map<String, Object> params = new HashMap<>();
            params.put("query", query);
            params.put("responseFields", responseFields);
            params.put("offset", offset);
            params.put("size", size);
            // TODO support rescorer(convert to map)
            // params.put("geoInfo", geoInfo);
            // params.put("facetInfo", facetInfo);

      <artifactId>junit-jupiter-api</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-params</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>

            if route.callbacks:
                callback_flat_models.extend(get_fields_from_routes(route.callbacks))
            params = get_flat_params(route.dependant)
            request_fields_from_routes.extend(params)

    flat_models = callback_flat_models + list(
        body_fields_from_routes + responses_from_routes + request_fields_from_routes
    )
    return flat_models

        name = performanceTestProject.name + " (Trigger)"

        val os = Os.LINUX
        val type = performanceTestSpec.type

        applyDefaultSettings(os)
        params {
            text(
                "reverse.dep.*.performance.baselines",
                type.defaultBaselines,
                display = ParameterDisplay.PROMPT,
                allowEmpty = true,

        boostFunctionList.add(new FilterFunctionBuilder(filter, scoreFunction));
    }

    public RescorerBuilder<?>[] getRescorers(final Map<String, Object> params) {
        return queryRescorerList.stream().map(r -> r.evaluate(params)).filter(b -> b != null).toArray(n -> new RescorerBuilder<?>[n]);
    }

    public void addQueryRescorer(final QueryRescorer rescorer) {
        queryRescorerList.add(rescorer);

            spec.getClasspath().from(calculateWorkerClasspath());
            spec.getForkOptions().setMaxHeapSize("1g");
        });
        queue.submit(JApiCmpWorkAction.class, params -> params.getConfiguration().set(calculateWorkerConfiguration(baseline, current)));
    }

    @Inject
    protected abstract WorkerExecutor getWorkerExecutor();

    private Set<File> calculateWorkerClasspath() {

from fastapi.testclient import TestClient
from inline_snapshot import snapshot

from tests.utils import needs_py39, needs_py310, needs_pydanticv1, needs_pydanticv2


@pytest.fixture(
    name="client",
    params=[
        pytest.param("tutorial002", marks=needs_pydanticv2),
        pytest.param("tutorial002_py310", marks=[needs_py310, needs_pydanticv2]),
        pytest.param("tutorial002_an", marks=needs_pydanticv2),