}

    @Test
    public void test_generateSummaryResponse_singleDocWithinLimit() {
        client.setTestContextMaxChars(10000);
        client.setTestSystemPrompt("system");
        client.setTestSummarySystemPrompt("{{systemPrompt}}\n{{documentContent}}\n{{languageInstruction}}");

        final List<Map<String, Object>> documents = new ArrayList<>();

    app = FastAPI()

    @app.get("/")
    def test() -> MyModel:
        return MyModel(custom_field=FakeNumpyArray())

    client = TestClient(app)
    return client


def test_get(client: TestClient):
    response = client.get("/")
    assert response.json() == {"custom_field": [1.0, 2.0, 3.0]}


def test_typeadapter():

    client =
      OkHttpClient
        .Builder()
        .proxy(server.proxyAddress)
        .build()
    server.enqueue(MockResponse(body = "abc"))
    server.enqueue(MockResponse(body = "def"))
    server.enqueue(MockResponse(body = "ghi"))
    client = client.newBuilder().build()
    executeSynchronously("/a").assertBody("abc")
    client = client.newBuilder().build()

def test_optional_list_str_missing(path: str):
    client = TestClient(app)
    response = client.get(path)
    assert response.status_code == 200, response.text
    assert response.json() == {"p": None}


@pytest.mark.parametrize(
    "path",
    ["/optional-list-str", "/model-optional-list-str"],
)
def test_optional_list_str(path: str):
    client = TestClient(app)
    response = client.get(path, headers=[("p", "hello"), ("p", "world")])

    )

  fun newRoutePlanner(
    client: OkHttpClient,
    address: Address = newAddress(),
  ): RealRoutePlanner {
    val call = RealCall(client, Request(address.url), forWebSocket = false)
    val chain = newChain(call)
    return RealRoutePlanner(
      taskRunner = client.taskRunner,
      connectionPool = client.connectionPool.delegate,
      readTimeoutMillis = client.readTimeoutMillis,

        String s = Config.getProperty("jcifs.smb1.smb.client.TreeConnectAndX.CheckDirectory");

        if (s != null) {
            batchLimits[0] = Byte.parseByte(s);
        }
        if ((s = Config.getProperty("jcifs.smb1.smb.client.TreeConnectAndX.CreateDirectory")) != null) {
            batchLimits[2] = Byte.parseByte(s);
        }
        if ((s = Config.getProperty("jcifs.smb1.smb.client.TreeConnectAndX.Delete")) != null) {

            }
        ]
    )


@pytest.mark.parametrize(
    "path",
    ["/required-list-str", "/model-required-list-str"],
)
def test_required_list_str_missing(path: str):
    client = TestClient(app)
    response = client.get(path)
    assert response.status_code == 422
    assert response.json() == {
        "detail": [
            {
                "type": "missing",
                "loc": ["query", "p"],

    }
  }

  @Test
  fun none() {
    server.enqueue(MockResponse())
    client.newCall(request().build()).execute()
    applicationLogs.assertNoMoreLogs()
    networkLogs.assertNoMoreLogs()
  }

  @Test
  fun basicGet() {
    setLevel(Level.BASIC)
    server.enqueue(MockResponse())
    client.newCall(request().build()).execute()
    applicationLogs
      .assertLogEqual("--> GET $url")

        return Facility(
            id=facility_id,
            address=Address(line_1="123 Main St", city="Anytown", state_province="CA"),
        )

    client = TestClient(app)
    return client


def test_get(client: TestClient):
    response = client.get("/facilities/42")
    assert response.status_code == 200, response.text
    assert response.json() == {
        "id": "42",
        "address": {

client = TestClient(app)


def test_security_http_basic():
    response = client.get("/users/me", auth=("john", "secret"))
    assert response.status_code == 200, response.text
    assert response.json() == {"username": "john", "password": "secret"}


def test_security_http_basic_no_credentials():
    response = client.get("/users/me")