when:
        touch(foo)
        then:
        foo.file
        foo.text == "data"
        foo.lastModified() > original
    }

    def "touch touches existing directory"() {
        def foo = temp.file("foo").createDir()
        def child = foo.file("data.txt") << "data"
        def original = foo.makeOlder().lastModified()

        when:
        touch(foo)
        then:

        when:
        new SingleDepthFileAccessTracker(journal, baseDir, 1).markAccessed(fileInOtherDirectory)

        then:
        0 * journal.setLastAccessTime(_, _)
    }

    def "touches all subdirectories for depth #depth"() {
        given:
        def file1 = baseDir.file("a/aa/aaa/1")
        def file2 = baseDir.file("b/bb/bbb/2")
        def expectedTouchedFiles = touchedPaths.collect { baseDir.file(it) }

branch during backports as long it is self contained. There are situations however this may lead to conflicts and the patch will not cleanly apply. Conflicts might be trivial which can be resolved easily, when conflicts seem to be non-trivial or touches the part of the code-base the developer is not confident - to get additional clarity reach out to #hack on MinIOHQ slack channel. Hasty changes must be avoided, minor fixes and logs may be added to hotfix branches but this should not be followed as...

        daemon.logContains(logLineCountBeforeChange, NativeLogger.name)
    }

    @Requires(
        value = IntegTestPreconditions.NotConfigCached,
        reason = """With cc it can happen on Mac that cc touches FS before we setup logger and some events
            are logged as [DEBUG] before we manage to disable debug logging, see also https://github.com/gradle/gradle/issues/25462"""
    )

   * @since 24.0
   */
  Set<EndpointPair<N>> incidentEdges(N node);

  /**
   * Returns the count of {@code node}'s incident edges, counting self-loops twice (equivalently,
   * the number of times an edge touches {@code node}).
   *
   * <p>For directed graphs, this is equal to {@code inDegree(node) + outDegree(node)}.
   *
   * <p>For undirected graphs, this is equal to {@code incidentEdges(node).size()} + (number of

   * @since 24.0
   */
  Set<EndpointPair<N>> incidentEdges(N node);

  /**
   * Returns the count of {@code node}'s incident edges, counting self-loops twice (equivalently,
   * the number of times an edge touches {@code node}).
   *
   * <p>For directed graphs, this is equal to {@code inDegree(node) + outDegree(node)}.
   *
   * <p>For undirected graphs, this is equal to {@code incidentEdges(node).size()} + (number of

* Les certificats ont une durée de vie.
    * Ils expirent.
    * Puis ils doivent être renouvelés et acquis à nouveau auprès de la tierce partie.
* Le cryptage de la connexion se fait au niveau du protocole TCP.
    * C'est une couche en dessous de HTTP.
    * Donc, le certificat et le traitement du cryptage sont faits avant HTTP.
* TCP ne connaît pas les "domaines", seulement les adresses IP.

apple-touch-icon-180x180.png...

L'utiliser dans votre éditeur est ce qui vous montre vraiment les avantages de FastAPI, en voyant le peu de code que vous avez à écrire, toutes les vérifications de type, l'autocomplétion, etc.

---

## Installer FastAPI

La première étape consiste à installer FastAPI.

Pour le tutoriel, vous voudrez peut-être l'installer avec toutes les dépendances et fonctionnalités optionnelles :

<div class="termy">

```console
$ pip install fastapi[all]

# Guide de l'utilisateur avancé

## Caractéristiques supplémentaires

Le [Tutoriel - Guide de l'utilisateur](../tutorial/index.md){.internal-link target=_blank} devrait suffire à vous faire découvrir toutes les fonctionnalités principales de **FastAPI**.

Dans les sections suivantes, vous verrez des options, configurations et fonctionnalités supplémentaires.

!!! note "Remarque"
    Les sections de ce chapitre ne sont **pas nécessairement "avancées"**.