}

  @Test fun `deflate golden value`() {
    val deflater = MessageDeflater(false)
    val deflated = deflater.deflate("Hello deflate!".encodeUtf8())
    assertThat(deflated.hex()).isEqualTo("f248cdc9c95748494dcb492c49550400")
  }

  @Test fun `inflate deflate`() {
    val deflater = MessageDeflater(false)
    val inflater = MessageInflater(false)

            return False
        dunder_call = getattr(_impartial(self.call), "__call__", None)  # noqa: B004
        if dunder_call is None:
            return False  # pragma: no cover
        if inspect.isgeneratorfunction(
            _impartial(dunder_call)
        ) or inspect.isgeneratorfunction(_unwrapped_call(dunder_call)):
            return True

    }

    /**
     * Compresses data using LZ77 algorithm (implemented using Java's Deflater).
     */
    private byte[] compressLZ77(byte[] data, int offset, int length) throws CIFSException {
        try {
            Deflater deflater = new Deflater(COMPRESSION_LEVEL, false);
            deflater.setInput(data, offset, length);
            deflater.finish();

            ByteArrayOutputStream baos = new ByteArrayOutputStream(length);

            isinstance(field_info, params.Param)
            and getattr(field_info, "in_", None) is None
        ):
            field_info.in_ = params.ParamTypes.query
        use_annotation_from_field_info = use_annotation
        if isinstance(field_info, params.Form):
            ensure_multipart_is_installed()
        if not field_info.alias and getattr(field_info, "convert_underscores", None):

        // Test setAttr
        tag.setAttr("data-role", "button");
        assertTrue(tag.toString().contains("attrName=data-role"));
        assertTrue(tag.toString().contains("attrValue=button"));

        // Test overwriting values
        tag.setId("new-id");
        tag.setCss("new-class");
        tag.setAttr("role", "link");

            openapi_examples = getattr(field_info, "openapi_examples", None)
            example = getattr(field_info, "example", None)
            if openapi_examples:
                parameter["examples"] = jsonable_encoder(openapi_examples)
            elif example is not _Unset:
                parameter["example"] = jsonable_encoder(example)
            if getattr(field_info, "deprecated", None):

def test_route_classes():
    routes = {}
    for r in app.router.routes:
        assert isinstance(r, Route)
        routes[r.path] = r
    assert getattr(routes["/a/"], "x_type") == "A"  # noqa: B009
    assert getattr(routes["/a/b/"], "x_type") == "B"  # noqa: B009
    assert getattr(routes["/a/b/c/"], "x_type") == "C"  # noqa: B009


def test_openapi_schema():
    response = client.get("/openapi.json")

from starlette.responses import JSONResponse, Response
from starlette.status import WS_1008_POLICY_VIOLATION


async def http_exception_handler(request: Request, exc: HTTPException) -> Response:
    headers = getattr(exc, "headers", None)
    if not is_body_allowed_for_status_code(exc.status_code):
        return Response(status_code=exc.status_code, headers=headers)
    return JSONResponse(

        # Make the FIRST file slower *deterministically*
        if self.filename == "slow.txt":
            await anyio.sleep(0.05)
        return await original_read(self, size)

    monkeypatch.setattr(StarletteUploadFile, "read", patched_read)

    client = TestClient(app)

    files = [
        ("files", ("slow.txt", b"A" * 10, "text/plain")),
        ("files", ("fast.txt", b"B" * 10, "text/plain")),
    ]

### Ler um Único Hero { #read-one-hero }

Podemos **ler** um único `Hero`.

{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[58:63] hl[60] *}

### Deletar um Hero { #delete-a-hero }

Também podemos **deletar** um `Hero`.

{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[66:73] hl[71] *}

### Executar o App { #run-the-app }

Você pode executar o app: