val rootBuildDir: DirectoryProperty
    }

    private val projectStates: ConcurrentHashMap<String, TestFilesCleanupProjectState> = ConcurrentHashMap()

    /**
     * Key is the path of a task, value is the possible report dirs it generates.
     */
    private val taskPathToReports: ConcurrentHashMap<String, List<ReportLocation>> = ConcurrentHashMap()

    /**
     * @see ReportLocation.resolve
     */
    @Volatile

    putEdge(4, 5);
  }

  // Element Mutation

  @Test
  public void putEdge_existingNodes() {
    assume().that(graphIsMutable()).isTrue();

    // Adding nodes initially for safety (insulating from possible future
    // modifications to proxy methods)
    addNode(N1);
    addNode(N2);

    assertThat(graphAsMutableGraph.putEdge(N1, N2)).isTrue();
  }

  @Test

### Installer Python et mettre à jour `PATH` { #installing-python-and-updating-the-path }

Lorsque vous installez Python, il est possible que l'on vous demande si vous souhaitez mettre à jour la variable d'environnement `PATH`.

//// tab | Linux, macOS

Supposons que vous installiez Python et qu'il se retrouve dans un répertoire `/opt/custompython/bin`.

                return Result.OK;
            } finally {
                reader.dispose();
            }
        }
        return Result.FAILED;
    }

    /**
     * Enumeration representing the possible results of thumbnail image processing.
     */
    protected enum Result {
        /** Thumbnail was successfully generated */
        OK,
        /** Thumbnail generation failed due to processing errors */

     * authority. Instead, it will trust any well-formed certificate, even if it is self-signed.
     * This is necessary for testing against localhost or in development environments where a
     * certificate authority is not possible.
     *
     * The server’s TLS certificate still must match the requested hostname. For example, if the
     * certificate is issued to `example.com` and the request is to `localhost`, the connection will

   *
   * @since 14.0
   */
  public static UnsignedInteger fromIntBits(int bits) {
    return new UnsignedInteger(bits);
  }

  /**
   * Returns an {@code UnsignedInteger} that is equal to {@code value}, if possible. The inverse
   * operation of {@link #longValue()}.
   */
  public static UnsignedInteger valueOf(long value) {
    checkArgument(
        (value & INT_MASK) == value,

      <name>PersistedToolchains</name>
      <superClass>TrackableBase</superClass>
      <description>
        The {@code &lt;toolchains&gt;} element is the root of the descriptor.
        The following table lists all the possible child elements.
      </description>
      <version>1.0.0+</version>
      <fields>
        <field>
          <name>toolchains</name>
          <version>1.0.0+</version>

    hashed_password = hashed_password,
)
```

/// warning | Alertes

Les fonctions auxiliaires `fake_password_hasher` et `fake_save_user` ne servent qu'à démontrer un flux de données possible, mais elles n'offrent évidemment aucune sécurité réelle.

///

## Réduire la duplication { #reduce-duplication }

Réduire la duplication de code est l'une des idées centrales de **FastAPI**.

    /**
     * Number of set bits (1s).
     *
     * <p>Note that because of concurrent set calls and uses of atomics, this bitCount is a (very)
     * close *estimate* of the actual number of bits set. It's not possible to do better than an
     * estimate without locking. Note that the number, if not exactly accurate, is *always*
     * underestimating, never overestimating.
     */
    long bitCount() {
      return bitCount.sum();

internal fun FileSystem.deleteIfExists(path: Path) {
  try {
    delete(path)
  } catch (fnfe: FileNotFoundException) {
    return
  }
}

/** Tolerant delete, try to clear as many files as possible even after a failure. */
internal fun FileSystem.deleteContents(directory: Path) {
  var exception: IOException? = null
  val files =
    try {
      list(directory)
    } catch (fnfe: FileNotFoundException) {