@app.get("/users/{user_id}", dependencies=[Depends(user_exists)])
async def read_users(user_id: int):
    pass


client = TestClient(app)


def test_read_users():
    response = client.get("/users/42")
    assert response.status_code == 200, response.text


def test_openapi_schema():
    response = client.get("/openapi.json")
    data = response.json()
    assert data == {
        "openapi": "3.1.0",

from fastapi.testclient import TestClient

from docs_src.configure_swagger_ui.tutorial003_py39 import app

client = TestClient(app)


def test_swagger_ui():
    response = client.get("/docs")
    assert response.status_code == 200, response.text
    assert '"deepLinking": false,' in response.text, (
        "overridden configs should be preserved"
    )
    assert '"deepLinking": true' not in response.text, (

        .build()
    val client =
      HandshakeCertificates
        .Builder()
        .addTrustedCertificate(serverRoot.certificate)
        .heldCertificate(clientCertificate, clientIntermediate.certificate)
        .build()
    val serverAddress = startTlsServer()
    val serverHandshakeFuture = doServerHandshake(server)
    val clientHandshakeFuture = doClientHandshake(client, serverAddress)

import org.codelibs.fess.Constants;
import org.codelibs.fess.app.service.WebConfigService;
import org.codelibs.fess.crawler.client.http.Authentication;
import org.codelibs.fess.crawler.client.http.form.FormScheme;
import org.codelibs.fess.crawler.client.http.impl.AuthenticationImpl;
import org.codelibs.fess.crawler.client.http.ntlm.JcifsEngine;
import org.codelibs.fess.crawler.exception.CrawlerSystemException;

    def create_person(person: PersonCreate) -> Any:
        db_person = Person.model_validate(person)
        return db_person

    client = TestClient(app)

    person_data = {"name": "Dive", "lastname": "Wilson"}
    response = client.post("/people/", json=person_data)
    data = response.json()
    assert response.status_code == 200, response.text
    assert data["name"] == person_data["name"]

### Build execution model

Gradle generally does some work in response to a client request. There are several different clients, for example the `gradlew` command or the tooling API client, 
that can send requests to a Gradle daemon.
Each daemon runs one request at a time. Generally speaking, the daemons only act in response to a request from a client and do not take any action on their own.

async def read_admin():
    return {"message": "Admin Access"}


client = TestClient(app)


def test_read_admin():
    response = client.get("/admin", headers={"Authorization": "Bearer faketoken"})
    assert response.status_code == 200, response.text
    assert response.json() == {"message": "Admin Access"}


def test_openapi_schema():
    response = client.get("/openapi.json")
    assert response.status_code == 200, response.text

    }

    /**
     * Sets the client computer name.
     *
     * @param clientComputerName the client computer name
     */
    public void setClientComputerName(String clientComputerName) {
        this.clientComputerName = clientComputerName;
    }

    /**
     * Gets the client computer name.
     *
     * @return the client computer name
     */

public static final String USE_RDMA = "jcifs.smb.client.useRDMA";
public static final String RDMA_PROVIDER = "jcifs.smb.client.rdmaProvider";
public static final String RDMA_READ_WRITE_THRESHOLD = "jcifs.smb.client.rdmaReadWriteThreshold";
public static final String RDMA_MAX_SEND_SIZE = "jcifs.smb.client.rdmaMaxSendSize";
public static final String RDMA_MAX_RECEIVE_SIZE = "jcifs.smb.client.rdmaMaxReceiveSize";

 * to mutate the event parameters, or be re-entrant back into the client. Any IO - writing to files
 * or network should be done asynchronously.
 */
abstract class EventListener {
  /**
   * Invoked as soon as a call is enqueued or executed by a client. In case of thread or stream
   * limits, this call may be executed well before processing the request is able to begin.
   *