for ( Response response : this.response_map.values() ) {
                                response.error();
                            }
                        }
                        throw new IOException("end of stream");
                    }

                    Response response = this.response_map.get(key);
                    if ( response == null ) {

  private fun writeHttpResponse(
    socket: Socket,
    sink: BufferedSink,
    response: MockResponse,
  ) {
    sleepNanos(response.headersDelayNanos)
    sink.writeUtf8(response.status)
    sink.writeUtf8("\r\n")

    writeHeaders(sink, response.headers)

    val body = response.body ?: return
    sleepNanos(response.bodyDelayNanos)
    val responseBodySink =
      sink.withThrottlingAndSocketPolicy(

    assert response.status_code == 400, response.text
    assert response.json() == {"detail": "Incorrect username or password"}


@needs_py310
def test_no_token(client: TestClient):
    response = client.get("/users/me")
    assert response.status_code == 401, response.text
    assert response.json() == {"detail": "Not authenticated"}
    assert response.headers["WWW-Authenticate"] == "Bearer"


@needs_py310

def test_openapi_schema(client: TestClient):
    response = client.get("/openapi.json")
    assert response.status_code == 200, response.text
    assert response.json() == {
        "openapi": "3.1.0",
        "info": {"title": "FastAPI", "version": "0.1.0"},
        "paths": {
            "/files/": {
                "post": {
                    "responses": {
                        "200": {

def test_query_param():
    response = client.get("/query/param")
    assert response.status_code == 200
    assert response.json() == "foo bar"


def test_query_param_query_50():
    response = client.get("/query/param?query=50")
    assert response.status_code == 200
    assert response.json() == "foo bar 50"


def test_query_param_required():
    response = client.get("/query/param-required")

    /** Don't accept an unvalidated cached response. */
    fun noCache() = commonNoCache()

    /** Don't store the server's response in any cache. */
    fun noStore() = commonNoStore()

    /**
     * Only accept the response if it is in the cache. If the response isn't cached, a `504
     * Unsatisfiable Request` response will be returned.
     */
    fun onlyIfCached() = commonOnlyIfCached()

    test_user = {"email": "******@****.***", "password": "secret"}
    response = client.post("/users/", json=test_user)
    assert response.status_code == 200, response.text
    data = response.json()
    assert test_user["email"] == data["email"]
    assert "id" in data
    response = client.post("/users/", json=test_user)
    assert response.status_code == 400, response.text


# TODO: pv2 add version with Pydantic v2
@needs_pydanticv1

                response = (NameServicePacket)responseTable.get( new Integer( nameTrnId ));
                if( response == null || response.received ) {
                    continue;
                }
                synchronized( response ) {
                    response.readWireFormat( rcv_buf, 0 );
                    response.received = true;

                    if( log.level > 3 ) {

      }
    }

    constructor(response: Response) {
      this.url = response.request.url
      this.varyHeaders = response.varyHeaders()
      this.requestMethod = response.request.method
      this.protocol = response.protocol
      this.code = response.code
      this.message = response.message
      this.responseHeaders = response.headers
      this.handshake = response.handshake

    cacheRequest: CacheRequest?,
    response: Response,
  ): Response {
    // Some apps return a null body; for compatibility we treat that like a null cache request.
    if (cacheRequest == null) return response
    val cacheBodyUnbuffered = cacheRequest.body()

    val source = response.body.source()
    val cacheBody = cacheBodyUnbuffered.buffer()

    val cacheWritingSource =
      object : Source {