this.allRecordCount = allRecordCount;
        }

        @Override
        protected SearchResult search(String query, SearchRequestParams params, OptionalThing<FessUserBean> userBean) {
            int start = params.getStartPosition();
            int size = params.getPageSize();
            SearchResultBuilder builder = SearchResult.create();
            for (int i = start; i < start + size && i < allRecordCount; i++) {

def test_get_invalid():
    response = client.get("/foo")
    assert response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY


def test_get_valid():
    response = client.get("/foo", params={"client_id": "bar"})
    assert response.status_code == 200

import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Timeout
import org.junit.jupiter.api.extension.RegisterExtension
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ValueSource

@Flaky // STDOUT logging enabled for test
@Timeout(30)
@Tag("Slow")
open class ConnectionListenerTest {
  @RegisterExtension
  val platform = PlatformRule()

        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)

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

            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);

            if parameters:
                all_parameters = {
                    (param["in"], param["name"]): param for param in parameters
                }
                required_parameters = {
                    (param["in"], param["name"]): param
                    for param in parameters
                    if param.get("required")
                }

        classMetaData.addMethod(METHOD_NAME, TypeMetaData.VOID, null)
        classMetaData.addMethod(METHOD_NAME, TypeMetaData.VOID, null).addParameter('param1', new TypeMetaData("java.lang.Integer"))
        def overloadedCalculateMethod = classMetaData.addMethod('calculate', TypeMetaData.VOID, null)
        overloadedCalculateMethod.addParameter('x', new TypeMetaData("java.lang.Integer"))

    """.trimIndent()
    detectHangingBuilds = false
    requirements {
        requiresNotEc2Agent()
        requiresNotSharedHost()
    }
    params {
        param("env.JPROFILER_HOME", os.jprofilerHome)
        param("performance.db.username", "tcagent")
    }
}

fun performanceTestCommandLine(
    task: String,
    baselines: String,
    extraParameters: String = "",

        "type":       "lowercase",
        "language":   "turkish"
      },
      "turkish_keywords": {
        "type":       "keyword_marker",
        "keywords": ["Merhaba", "Dünya", "arama"]
      },
      "turkish_stemmer": {
        "type":       "stemmer",
        "language":   "turkish"
      },
      "thai_stop": {
        "type":       "stop",
        "stopwords":  "_thai_"