}
    }

    /**
     * Clears all session contexts (for cleanup).
     */
    public void cleanup() {
        for (PreauthIntegrityContext context : sessionContexts.values()) {
            context.invalidate();
        }
        sessionContexts.clear();
        log.debug("Cleaned up all preauth integrity contexts");
    }

     */
    public List<FileInfo> getChildren() {
        lock.readLock().lock();
        try {
            lastAccessTime = System.currentTimeMillis();
            return new ArrayList<>(children.values());
        } finally {
            lock.readLock().unlock();
        }
    }

    /**
     * Get a specific child
     *
     * @param name child name

            n = in.read(b, off + i, len - i);
            if (n <= 0) {
                break;
            }
            i += n;
        }

        return i;
    }

    /* state values
     * 0 - not connected
     * 1 - connecting
     * 2 - run connected
     * 3 - connected
     * 4 - error
     */
    int state = 0;

    String name = "Transport" + id++;
    Thread thread;

/// note | Remarque

**FastAPI** saura que la valeur de `q` n'est pas requise grâce à la valeur par défaut `= None`.

L'annotation de type `str | None` n'est pas utilisée par **FastAPI** pour déterminer que la valeur n'est pas requise, il le saura parce qu'elle a une valeur par défaut `= None`.

    }

    @Test
    public void test_execute_withNonPhraseQuery() {
        // Test with non-phrase query - should throw InvalidQueryException
        Query termQuery = new TermQuery(new Term("field", "value"));
        QueryContext context = new QueryContext("test", false);

        try {
            queryCommand.execute(context, termQuery, 1.0f);
            fail("Should throw InvalidQueryException for non-phrase query");

  }

  public <T> void testWhere_mapFromBoundedWildcard() {
    Type subtype = new TypeCapture<TypedKeyMap<T>>() {}.capture();
    // TODO(benyu): This should check equality to an expected value, see discussion in cl/98674873
    Type unused =
        new TypeResolver()
            .where(
                new TypeCapture<Map<Integer, T>>() {}.capture(),

        // Act
        int bytesWritten = trans.writeDataWireFormat(dst, 0);

        // Assert
        assertEquals(0, bytesWritten);
    }

    @Test
    @DisplayName("Test with large FID value")
    void testWithLargeFid() {
        // Arrange
        int largeFid = 0xFFFF;
        TransTransactNamedPipe trans = new TransTransactNamedPipe(mockConfig, largeFid, TEST_DATA, TEST_OFFSET, TEST_LENGTH);

Instead of configuring an external KMS you can start with a single key by
setting the env. variable `MINIO_KMS_SECRET_KEY`. It expects the following
format:

```sh
MINIO_KMS_SECRET_KEY=<key-name>:<base64-value>
```

First generate a 256 bit random key via:

```sh
$ cat /dev/urandom | head -c 32 | base64 -
OSMM+vkKUTCvQs9YL/CVMIMt43HFhkUpqJxTmGl6rYw=
```

Now, you can set `MINIO_KMS_SECRET_KEY` like this:

   * request is transmitted. This is only interesting for duplex calls where the request and
   * response may be interleaved.
   *
   * Read this value only once for each enter/exit pair because its value can change.
   */
  private fun doReadTimeout() = !connection.client || sink.closed || sink.finished

  /**

{* ../../docs_src/response_model/tutorial004_py310.py hl[9,11:12] *}

* `description: Union[str, None] = None` (ou `str | None = None` en Python 3.10) a une valeur par défaut `None`.
* `tax: float = 10.5` a une valeur par défaut `10.5`.
* `tags: List[str] = []` a une valeur par défaut de liste vide : `[]`.

mais vous pourriez vouloir les omettre du résultat si elles n'ont pas été réellement stockées.