{"000000000000bogus", 0, "invalid byte in chunk length"},
		{"00000000000000000", 0, "http chunk length too large"}, // could accept if we wanted
		{"10000000000000000", 0, "http chunk length too large"},
		{"00000000000000001", 0, "http chunk length too large"}, // could accept if we wanted
	}
	for i := uint64(0); i <= 1234; i++ {
		tests = append(tests, testCase{in: fmt.Sprintf("%x", i), want: i})
	}
	for _, tt := range tests {

{* ../../docs_src/async_tests/app_a_py310/test_main.py hl[9:12] *}

Це еквівалентно:

```Python
response = client.get('/')
```

...що ми раніше використовували для надсилання запитів за допомогою `TestClient`.

/// tip | Порада

Зауважте, що ми використовуємо async/await із новим `AsyncClient` - запит є асинхронним.

///

        // Start timing
        long overallStart = System.nanoTime();

        for (int t = 0; t < threadCount; t++) {
            executor.submit(() -> {
                try {
                    startLatch.await();

                    long threadStart = System.nanoTime();
                    for (int i = 0; i < operationsPerThread; i++) {
                        try {

Luego podemos crear un `AsyncClient` con la app y enviar requests asíncronos a ella, usando `await`.

{* ../../docs_src/async_tests/app_a_py310/test_main.py hl[9:12] *}

Esto es equivalente a:

```Python
response = client.get('/')
```

...que usábamos para hacer nuestros requests con el `TestClient`.

/// tip | Consejo

Nota que estamos usando async/await con el nuevo `AsyncClient`: el request es asíncrono.

///

{* ../../docs_src/async_tests/app_a_py310/test_main.py hl[9:12] *}

C'est l'équivalent de :

```Python
response = client.get('/')
```

... que nous utilisions pour faire nos requêtes avec le `TestClient`.

/// tip | Astuce

Notez que nous utilisons async/await avec le nouveau `AsyncClient` — la requête est asynchrone.

///

    async def patched_read(self: StarletteUploadFile, size: int = -1) -> bytes:
        # 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")),

- `seek(offset)` : se déplace à la position d'octet `offset` (`int`) dans le fichier.
    - Par ex., `await myfile.seek(0)` irait au début du fichier.
    - C'est particulièrement utile si vous exécutez `await myfile.read()` une fois puis devez relire le contenu.
- `close()` : ferme le fichier.

Comme toutes ces méthodes sont `async`, vous devez les « await ».

* `seek(offset)`: Va a la posición de bytes `offset` (`int`) en el archivo.
    * Por ejemplo, `await myfile.seek(0)` iría al inicio del archivo.
    * Esto es especialmente útil si ejecutas `await myfile.read()` una vez y luego necesitas leer el contenido nuevamente.
* `close()`: Cierra el archivo.

Como todos estos métodos son métodos `async`, necesitas "await" para ellos.

        original_route_handler = super().get_route_handler()

        async def custom_route_handler(request: Request) -> Response:
            try:
                return await original_route_handler(request)
            except RequestValidationError as exc:
                body = await request.body()
                detail = {"errors": exc.errors(), "body": body.decode()}
                raise HTTPException(status_code=422, detail=detail)

   */
  public void assertSuccess(Object expectedData) throws Throwable {
    // Verify that the listener executed in a reasonable amount of time.
    Assert.assertTrue(countDownLatch.await(1L, SECONDS));

    try {
      Assert.assertEquals(expectedData, future.get());
    } catch (ExecutionException e) {
      throw e.getCause();
    }
  }

  /**