*       </ul>
 *   <li>When an entry is evicted from the cache, {@code evictionCount} is incremented.
 *   <li>No stats are modified when a cache entry is invalidated or manually removed.
 *   <li>No stats are modified by operations invoked on the {@linkplain Cache#asMap asMap} view of
 *       the cache.
 * </ul>
 *
 * <p>A lookup is specifically defined as an invocation of one of the methods {@link

 *       </ul>
 *   <li>When an entry is evicted from the cache, {@code evictionCount} is incremented.
 *   <li>No stats are modified when a cache entry is invalidated or manually removed.
 *   <li>No stats are modified by operations invoked on the {@linkplain Cache#asMap asMap} view of
 *       the cache.
 * </ul>
 *
 * <p>A lookup is specifically defined as an invocation of one of the methods {@link

 * <pre>{@code
 * someGraphAlgorithm(startNode, node -> ImmutableList.of(node.mother(), node.father()));
 * }</pre>
 *
 * <p>Graph algorithms that need additional capabilities (accessing both predecessors and
 * successors, iterating over the edges, etc.) should declare their input to be of a type that
 * provides those capabilities, such as {@link Graph}, {@link ValueGraph}, or {@link Network}.
 *
 * <h3>Additional documentation</h3>
 *

                .build();
    }

    private Dependency injectDependency(Dependency d) {
        // we cannot set this directly in the MDO due to the interactions with dependency management
        return (d.getScope() == null || d.getScope().isEmpty()) ? d.withScope("compile") : d;
    }

    /**
     * Returns a list suited for the builders, i.e. null if not modified

# Tâches d'arrière-plan

Vous pouvez définir des tâches d'arrière-plan qui seront exécutées après avoir retourné une réponse.

Ceci est utile pour les opérations qui doivent avoir lieu après une requête, mais où le client n'a pas réellement besoin d'attendre que l'opération soit terminée pour recevoir une réponse.

Cela comprend, par exemple :

* Les notifications par email envoyées après l'exécution d'une action :

	ExecObjectLayerTest(t, testGetObjectInfo)
}

// Testing GetObjectInfo().
func testGetObjectInfo(obj ObjectLayer, instanceType string, t TestErrHandler) {
	// This bucket is used for testing getObjectInfo operations.
	err := obj.MakeBucket(context.Background(), "test-getobjectinfo", MakeBucketOptions{})
	if err != nil {
		t.Fatalf("%s : %s", instanceType, err.Error())
	}
	opts := ObjectOptions{}

 *
 * <p>The simplest use case is:
 *
 * <pre>
 * new EqualsTester().addEqualityGroup(foo).testEquals();
 * </pre>
 *
 * <p>This tests {@code foo.equals(foo)}, {@code foo.equals(null)}, and a few other operations.
 *
 * <p>For more extensive testing, add multiple equality groups. Each group should contain objects
 * that are equal to each other but unequal to the objects in any other group. For example:
 *
 * <pre>

In the example below, **FastAPI** will use `ORJSONResponse` by default, in all *path operations*, instead of `JSONResponse`.

```Python hl_lines="2  4"
{!../../docs_src/custom_response/tutorial010.py!}
```

/// tip

You can still override `response_class` in *path operations* as before.

///

## Additional documentation

 *   <li>{@link ContiguousSet}
 * </ul>
 *
 * <h2>Classes of static utility methods</h2>
 *
 * <ul>
 *   <li>{@link Collections2}
 *   <li>{@link Comparators}
 *   <li>{@link Iterables}
 *   <li>{@link Iterators}
 *   <li>{@link Lists}
 *   <li>{@link Maps}
 *   <li>{@link MoreCollectors}
 *   <li>{@link Multimaps}
 *   <li>{@link Multisets}
 *   <li>{@link ObjectArrays}
 *   <li>{@link Queues}
 *   <li>{@link Sets}

 *   <li>{@link ContiguousSet}
 * </ul>
 *
 * <h2>Classes of static utility methods</h2>
 *
 * <ul>
 *   <li>{@link Collections2}
 *   <li>{@link Comparators}
 *   <li>{@link Iterables}
 *   <li>{@link Iterators}
 *   <li>{@link Lists}
 *   <li>{@link Maps}
 *   <li>{@link MoreCollectors}
 *   <li>{@link Multimaps}
 *   <li>{@link Multisets}
 *   <li>{@link ObjectArrays}
 *   <li>{@link Queues}
 *   <li>{@link Sets}