/**
   * Sorts the elements of {@code array} in descending order.
   *
   * @since 23.1
   */
  public static void sortDescending(char[] array) {
    checkNotNull(array);
    sortDescending(array, 0, array.length);
  }

  /**
   * Sorts the elements of {@code array} between {@code fromIndex} inclusive and {@code toIndex}
   * exclusive in descending order.
   *
   * @since 23.1
   */

                        .inactiveRequiredProjects(MODULE_B)
                        .expectResult(MODULE_C_2, INDEPENDENT_MODULE),
                scenario("Selected projects in wrong order are resumed correctly in order")
                        .activeRequiredProjects(MODULE_C_2, MODULE_B, MODULE_A)
                        .resumeFrom(MODULE_B)
                        .expectResult(MODULE_B, MODULE_C_2),

                .repositories(repositories2)
                .build();

        ArtifactResolverRequest request3 = builder.session(session)
                .coordinates(Arrays.asList(coords2, coords1)) // Different order
                .repositories(repositories1)
                .build();

        // Test equals and hashCode
        assertEquals(request1, request2);
        assertEquals(request1.hashCode(), request2.hashCode());

import java.util.ArrayList;
import java.util.List;

/**
 * The NormalizerChain class implements the Normalizer interface and allows chaining multiple normalizers together.
 * It applies each normalizer in the order they were added to the chain.
 *
 * <p>Usage example:</p>
 * <pre>
 * NormalizerChain chain = new NormalizerChain();
 * chain.add(new SomeNormalizer());
 * chain.add(new AnotherNormalizer());

    /**
     * The possible types of execution events.
     *
     * Note: do not modify this enum, or, make sure that this enum and
     * {@link org.apache.maven.api.EventType} have same elements in same order.
     */
    enum Type {
        ProjectDiscoveryStarted,
        SessionStarted,
        SessionEnded,
        ProjectSkipped,
        ProjectStarted,
        ProjectSucceeded,
        ProjectFailed,

 * elementsToInsert}, the elements to be passed to {@code set()} and {@code add()} calls; {@code
 * features}, the features supported by the iterator; and {@code expectedElements}, the elements the
 * iterator should return in order.
 *
 * <p>The items in {@code elementsToInsert} will be repeated if {@code steps} is larger than the
 * number of provided elements.
 *
 * @author Chris Povirk
 */
@GwtCompatible
@NullMarked

  @Override
  public String[] createArray(int length) {
    return new String[length];
  }

  /** Returns the original element list, unchanged. */
  @Override
  public List<String> order(List<String> insertionOrder) {
    return insertionOrder;
  }

  @Override
  public Character[] createArray(int length) {
    return new Character[length];
  }

  /** Returns the original element list, unchanged. */
  @Override
  public List<Character> order(List<Character> insertionOrder) {
    return insertionOrder;
  }

  @Override
  public UnhashableObject[] createArray(int length) {
    return new UnhashableObject[length];
  }

  @Override
  public Iterable<UnhashableObject> order(List<UnhashableObject> insertionOrder) {
    return insertionOrder;
  }

                    return ImmutableSortedMultiset.copyOf(elements);
                  }

                  @Override
                  public List<String> order(List<String> insertionOrder) {
                    return Ordering.natural().sortedCopy(insertionOrder);
                  }
                })
            .named("ImmutableSortedMultiset")
            .withFeatures(