// ImmutableMap.Builder maintains the order of the elements as inserted, so the map will have
    // whatever ordering the graph's nodes do, so ImmutableSortedMap is unnecessary even if the
    // input nodes are sorted.
    ImmutableMap.Builder<N, GraphConnections<N, Presence>> nodeConnections = ImmutableMap.builder();
    for (N node : graph.nodes()) {
      nodeConnections.put(node, connectionsOf(graph, node));
    }

        }

        String result = scoreUpdater.execute();
        String[] lines = result.split("\n");
        assertEquals(100, lines.length);
    }

    // Test priority sorting with large range
    @Test
    public void test_addScoreBooster_largePriorityRange() {
        PriorityTrackingBooster booster1 = new PriorityTrackingBooster(Integer.MIN_VALUE, 100L);

 * they are thin wrapper around {@link java.util.Collections#emptySet()}, {@link
 * Collections#singleton(Object)} and {@link java.util.LinkedHashSet} for empty, singleton and
 * regular sets respectively. For the sorted sets, it's a thin wrapper around {@link
 * java.util.TreeSet}.
 *
 * @see ImmutableSortedSet
 * @author Hayward Chan
 */
@SuppressWarnings("serial") // Serialization only done in GWT.

///

<div class="termy">

```console
$ echo "*" > .venv/.gitignore
```

</div>

/// details | Que signifie cette commande

* `echo "*"` : va « afficher » le texte `*` dans le terminal (la partie suivante change un peu cela)
* `>` : tout ce qui est affiché dans le terminal par la commande à gauche de `>` ne doit pas être affiché mais écrit dans le fichier à droite de `>`

// ESCount returns the total number of erasure sets in this cluster
func (l EndpointServerPools) ESCount() (count int) {
	for _, p := range l {
		count += p.SetCount
	}
	return count
}

// GetNodes returns a sorted list of nodes in this cluster
func (l EndpointServerPools) GetNodes() (nodes []Node) {
	nodesMap := make(map[string]Node)
	for _, pool := range l {
		for _, ep := range pool.Endpoints {
			node, ok := nodesMap[ep.Host]

{* ../../docs_src/additional_responses/tutorial001_py310.py hl[18,22] *}

/// note | Remarque

Gardez à l'esprit que vous devez renvoyer directement `JSONResponse`.

///

/// info

La clé `model` ne fait pas partie d'OpenAPI.

**FastAPI** prendra le modèle Pydantic à partir de là, générera le `JSON Schema` et le placera au bon endroit.

Le bon endroit est :

                    sessionCache.size(), maxSize, toRemove);

            // Remove oldest sessions
            sessionCache.entrySet()
                    .stream()
                    .sorted((e1, e2) -> e1.getValue().getLastAccessedAt().compareTo(e2.getValue().getLastAccessedAt()))
                    .limit(toRemove)
                    .map(Map.Entry::getKey)
                    .collect(Collectors.toList())

            deleteDirectory(tempDir);
        }
        super.tearDown(testInfo);
    }

    private void deleteDirectory(Path dir) throws IOException {
        Files.walk(dir).sorted((a, b) -> b.compareTo(a)).forEach(path -> {
            try {
                Files.delete(path);
            } catch (IOException e) {
                // Ignore
            }
        });
    }

    @Test

/**
 * A generalized interval on any ordering, for internal use. Supports {@code null}. Unlike {@link
 * Range}, this allows the use of an arbitrary comparator. This is designed for use in the
 * implementation of subcollections of sorted collection types.
 *
 * <p>Whenever possible, use {@code Range} instead, which is better supported.
 *
 * @author Louis Wasserman
 */
@GwtCompatible

    checkNotNull(comparator);
    checkNotNull(keyFunction);
    checkNotNull(valueFunction);
    /*
     * We will always fail if there are duplicate keys, and the keys are always sorted by
     * the Comparator, so the entries can come in an arbitrary order -- so we report UNORDERED.
     */
    return Collector.of(
        () -> new ImmutableSortedMap.Builder<K, V>(comparator),