* @param supplier the supplier will compute the new value
     * @return the session data associated with the key
     */
    @Nullable
    <T> T computeIfAbsent(@Nonnull Key<T> key, @Nonnull Supplier<T> supplier);

    /**
     * Create a key using the given class as an identifier and as the type of the object.
     */
    static <T> Key<T> key(Class<T> clazz) {
        return new Key<>(clazz, clazz);
    }

    /**

    return CompactHashSet.create();
  }

  /**
   * Returns a new array of the given length with the same type as a reference array.
   *
   * @param reference any array of the desired type
   * @param length the length of the new array
   */
  /*
   * The new array contains nulls, even if the old array did not. If we wanted to be accurate, we

    "old key": "old value",
    "second old key": "second old value",
}
new_dict = {**old_dict, "new key": "new value"}
```

Aquí, `new_dict` contendrá todos los pares clave-valor de `old_dict` más el nuevo par clave-valor:

```Python
{
    "old key": "old value",
    "second old key": "second old value",
    "new key": "new value",
}
```

    "second old key": "second old value",
}
new_dict = {**old_dict, "new key": "new value"}
```

Hier wird `new_dict` alle Schlüssel-Wert-Paare von `old_dict` plus das neue Schlüssel-Wert-Paar enthalten:

```Python
{
    "old key": "old value",
    "second old key": "second old value",
    "new key": "new value",
}
```

import jakarta.validation.constraints.Size;

/**
 * Form class for creating new duplicate host configuration entries.
 * This form handles the creation of duplicate host mappings that redirect
 * crawling from duplicate hostnames to the regular canonical hostname.
 */
public class CreateForm {

    /**
     * Creates a new CreateForm instance.
     */
    public CreateForm() {
    }

    @Test
    void testGetProblems() {
        DefaultProblemCollector collector = new DefaultProblemCollector(null);
        assertNotNull(collector.getProblems());
        assertEquals(0, collector.getProblems().size());

        collector.add(null, "MESSAGE1", -1, -1, null);

        Exception e2 = new Exception();
        collector.add(Severity.WARNING, null, 42, 127, e2);

        return mojos;
    }

    public void setMojos(List<LifecycleMojo> mojos) {
        this.mojos = mojos;
    }

    public void set(String goals) {
        mojos = new ArrayList<>();

        if (goals != null && !goals.isEmpty()) {
            String[] mojoGoals = goals.split(",");
            mojos = Arrays.stream(mojoGoals).map(fromGoalIntoLifecycleMojo).collect(Collectors.toList());

    @ParameterizedTest
    @ValueSource(booleans = {true, false})
    void downstreamProjectsShouldBeCached(boolean transitive) {
        FilteredProjectDependencyGraph graph =
                new FilteredProjectDependencyGraph(projectDependencyGraph, List.of(aProject));

        when(projectDependencyGraph.getDownstreamProjects(bProject, transitive)).thenReturn(List.of(cProject));

        } catch (InvalidVersionSpecificationException e) {
            throw new IllegalArgumentException("Invalid 'requiredJavaVersion' given in plugin descriptor", e);
        }
        Version current;
        try {
            current = versionScheme.parseVersion(currentVersion);
        } catch (InvalidVersionSpecificationException e) {
            throw new IllegalStateException("Could not parse current Java version", e);
        }

     */
    @Test
    public void testErrorMessage_ja() throws Exception {
        // ## Arrange ##
        Locale.setDefault(Locale.JAPANESE);
        final NullArgumentException nullArgumentException = new NullArgumentException("hoge");
        assertThat(nullArgumentException.getArgName(), is("hoge"));
        assertThat(nullArgumentException.getMessage(), is("[ECL0008]argument[hoge] is null."));
    }

    /**