import com.google.caliper.Param;
import org.jspecify.annotations.NullUnmarked;

/**
 * Benchmarks against the Apache Commons Math utilities.
 *
 * <p>Note: the Apache benchmarks are not open sourced to avoid the extra dependency.
 *
 * @author Louis Wasserman
 */
@NullUnmarked
public class ApacheBenchmark {
  private enum Impl {
    GUAVA {
      @Override
      public double factorialDouble(int n) {

* list (as in Python list): list
* context manager: context manager (do not translate to "gestor de contexto" or "administrador de contexto")
* a little bit: un poquito
* graph (data structure, as in "dependency graph"): grafo (do not translate to "gráfico")
* form data: form data (do not translate to "datos de formulario" or "datos de form")
* import (as in code import): import (do not translate to "importación")

* Quaisquer argumentos nomeados que devem ser passados para a função de tarefa (`message="some notification"`).

## Injeção de dependências { #dependency-injection }

        StringBuilder sb = new StringBuilder();

        if (path != null) {
            sb.append(LS);
            sb.append(indentation);
            sb.append("Path to dependency: ");
            sb.append(LS);
            int num = 1;
            for (Iterator<String> i = path.iterator(); i.hasNext(); num++) {
                sb.append(indentation);
                sb.append('\t');

        assertEquals(weight1, weight2, "Project weight should be consistent");
    }

    @Test
    void testDependencyChainLength() {
        // Test that projects with longer dependency chains get higher weights
        // In the stub: A -> B,C; B -> X,Y; C -> X,Z
        long weightA = comparator.getProjectWeight(ProjectDependencyGraphStub.A);

Podemos fazer melhor...

## O que caracteriza uma dependência { #what-makes-a-dependency }

Até agora você apenas viu dependências declaradas como funções.

Mas essa não é a única forma de declarar dependências (mesmo que provavelmente seja a mais comum).

        }
        if (!failures.isEmpty()) {
            IllegalStateException mavenDiFailed = new IllegalStateException(
                    "Maven dependency injection failed for at least one of the registered core extension");
            failures.forEach(mavenDiFailed::addSuppressed);
            throw mavenDiFailed;
        }

participant handler as Exception handler
participant dep as Dep with yield
participant operation as Path Operation
participant tasks as Background tasks

    Note over client,tasks: Can raise exception for dependency, handled after response is sent
    Note over client,operation: Can raise HTTPException and can change the response
    client ->> dep: Start request
    Note over dep: Run code up to yield
    opt raise

            String originalPom = PomBuilder.create()
                    .groupId("com.example")
                    .artifactId("test-project")
                    .version("1.0.0")
                    .dependency("junit", "junit", "3.8.1") // Old version that should be flagged
                    .build();
            Files.writeString(pomFile, originalPom);

            UpgradeContext context = TestUtils.createMockContext(tempDir);

There you can set:

* The "Item ID", used in the path.
* The "Token" used as a query parameter.

/// tip

Notice that the query `token` will be handled by a dependency.

///

With that you can connect the WebSocket and then send and receive messages:

<img src="/img/tutorial/websockets/image05.png">