from fastapi.testclient import TestClient

from docs_src.custom_response.tutorial009c_py39 import app

client = TestClient(app)


def test_get():
    response = client.get("/")

 * </ul>
 *
 * <h3>Utility Classes</h3>
 * <ul>
 *   <li>{@link org.apache.maven.cling.invoker.mvnup.goals.StrategyOrchestrator} - Coordinates strategy execution</li>
 *   <li>{@link org.apache.maven.cling.invoker.mvnup.goals.PomDiscovery} - Discovers POM files in multi-module projects</li>

            "user_items": user_items,
        }

    return app


@pytest.fixture(name="client")
def client_fixture(app: FastAPI):
    return TestClient(app)


def test_security_scopes_sub_dependency_caching(
    client: TestClient, call_counts: dict[str, int]
):
    response = client.get("/")

    assert response.status_code == 200
    assert call_counts["get_db_session"] == 1

from fastapi.testclient import TestClient

from docs_src.custom_response.tutorial007_py39 import app

client = TestClient(app)


def test_get():
    fake_content = b"some fake video bytes"
    response = client.get("/")

app.include_router(router=router_a, prefix="/a")


client = TestClient(app)


@pytest.mark.parametrize(
    "path,expected_status,expected_response",
    [
        ("/a", 200, {"msg": "A"}),
        ("/a/b", 200, {"msg": "B"}),
        ("/a/b/c", 200, {"msg": "C"}),
    ],
)
def test_get_path(path, expected_status, expected_response):
    response = client.get(path)
    assert response.status_code == expected_status

			for {
				select {
				case <-ctx.Done():
					return
				case <-timer.C:
					client.DescribeKey(ctx, defaultKey)
				}
			}
		}()

		return &KMS{
			Type:       MinKES,
			DefaultKey: env.Get(EnvKESDefaultKey, ""),
			conn: &kesConn{
				defaultKeyID: env.Get(EnvKESDefaultKey, ""),
				client:       client,
			},
			latencyBuckets: defaultLatencyBuckets,

        Dns.SYSTEM.lookup(server.hostName)
      }

    val client =
      clientTestRule
        .newClientBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).dns(dns)
        .build()

    server.enqueue(MockResponse())

    val call =
      client.newCall(
        Request(

@app.get("/items/")
def read_items(q: list[int] = Query(default=None)):
    return {"q": q}


client = TestClient(app)


def test_multi_query():
    response = client.get("/items/?q=5&q=6")
    assert response.status_code == 200, response.text
    assert response.json() == {"q": [5, 6]}


def test_multi_query_incorrect():
    response = client.get("/items/?q=five&q=six")
    assert response.status_code == 422, response.text

public final class PerCallSettings {
  private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("http://httpbin.org/delay/1") // This URL is served with a 1 second delay.
        .build();

    // Copy to customize OkHttp for this request.
    OkHttpClient client1 = client.newBuilder()
        .readTimeout(500, TimeUnit.MILLISECONDS)

import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public final class PreemptiveAuth {
  private final OkHttpClient client;

  public PreemptiveAuth() {
    client = new OkHttpClient.Builder()
        .addInterceptor(
            new BasicAuthInterceptor("publicobject.com", "jesse", "password1"))
        .build();
  }

  public void run() throws Exception {