* Arrays::compareUnsigned}.
   */
  public static Comparator<long[]> lexicographicalComparator() {
    return LexicographicalComparator.INSTANCE;
  }

  enum LexicographicalComparator implements Comparator<long[]> {
    INSTANCE;

    @Override
    public int compare(long[] left, long[] right) {
      int minLength = Math.min(left.length, right.length);

      }
      ImmutableLongArray iia = builder.build();
      for (int j = 0; j < iia.length(); j++) {
        assertThat(iia.get(j)).isEqualTo((long) j);
      }
    }
  }

  private enum BuilderOp {
    ADD_ONE {
      @Override
      void doIt(ImmutableLongArray.Builder builder, AtomicLong counter) {
        builder.add(counter.getAndIncrement());
      }
    },
    ADD_ARRAY {

import org.jspecify.annotations.Nullable;

/**
 * Supplies an arbitrary "default" instance for a wide range of types, often useful in testing
 * utilities.
 *
 * <p>Covers arrays, enums and common types defined in {@code java.lang}, {@code java.lang.reflect},
 * {@code java.io}, {@code java.nio}, {@code java.math}, {@code java.util}, {@code

    }

    @Override
    public Entry<K, V>[] createArray(int length) {
      return delegate.createArray(length);
    }
  }

  /** Two bounds (from and to) define how to build a subMap. */
  public enum Bound {
    INCLUSIVE,
    EXCLUSIVE,
    NO_BOUND;
  }

  public static class SortedSetSubsetTestSetGenerator<E extends @Nullable Object>
      implements TestSortedSetGenerator<E> {
    final Bound to;

    SupplierFunction<T> sf = (SupplierFunction<T>) SupplierFunctionImpl.INSTANCE;
    return sf;
  }

  private interface SupplierFunction<T extends @Nullable Object> extends Function<Supplier<T>, T> {}

  private enum SupplierFunctionImpl implements SupplierFunction<@Nullable Object> {
    INSTANCE;

    // Note: This makes T a "pass-through type"
    @Override
    public @Nullable Object apply(Supplier<@Nullable Object> input) {

      }
      ImmutableIntArray iia = builder.build();
      for (int j = 0; j < iia.length(); j++) {
        assertThat(iia.get(j)).isEqualTo(j);
      }
    }
  }

  private enum BuilderOp {
    ADD_ONE {
      @Override
      void doIt(ImmutableIntArray.Builder builder, AtomicInteger counter) {
        builder.add(counter.getAndIncrement());
      }
    },
    ADD_ARRAY {

 * such as agent paths.
 *
 * @see org.apache.maven.api.services.DependencyResolverResult#getDispatchedPaths()
 *
 * @since 4.0.0
 */
@Experimental
public enum JavaPathType implements PathType {
    /**
     * The path identified by the Java {@code --class-path} option.
     * Used for compilation, execution and Javadoc among others.

    /**
     * Enumeration of predefined statistics actions that can be recorded
     * during crawler operations. Each action represents a specific event
     * or milestone in the crawling process.
     */
    public enum StatsAction {
        /** Indicates that a URL was successfully accessed. */
        ACCESSED,
        /** Indicates that an exception occurred during URL access. */
        ACCESS_EXCEPTION,

    private final AtomicLong totalChannelsCreated = new AtomicLong(0);

    /**
     * Load balancing strategies for distributing operations across channels.
     */
    public enum LoadBalancingStrategy {
        /** Round-robin distribution */
        ROUND_ROBIN,
        /** Least connections */
        LEAST_CONNECTIONS,
        /** Random selection */
        RANDOM,

 * which case the root node of the resulting graph has no associated dependency.
 *
 * @since 4.0.0
 */
@Experimental
@Immutable
public interface DependencyResolverRequest extends RepositoryAwareRequest {

    enum RequestType {
        COLLECT,
        FLATTEN,
        RESOLVE
    }

    @Nonnull
    RequestType getRequestType();

    @Nonnull
    Optional<Project> getProject();

    @Nonnull