import org.eclipse.aether.resolution.ArtifactDescriptorResult;

/**
 * Maven relocation source.
 * Note: implementations of this component should avoid the "default" name (has special meaning in Eclipse Sisu) and
 * explicitly order implementations using Sisu priorities.
 *
 * @since 4.0.0
 */
public interface MavenArtifactRelocationSource {
    /**
     * Returns {@link Artifact} instance where to relocate to, or {@code null}.
     *

         * NOTE: This is primarily to keep backward-compat with Maven 2.x which did not validate that dependencies are
         * unique within a single POM. Upon multiple declarations, 2.x just kept the last one but retained the order of
         * the first occurrence. So when we're in lenient/compat mode, we have to deal with such broken POMs and mimic

    Helpers.testComparator(lexy, empty, a, aa, ab, b);

    new EqualsTester()
        .addEqualityGroup(lexy, Comparators.lexicographical(comparator))
        .addEqualityGroup(Comparators.lexicographical(String.CASE_INSENSITIVE_ORDER))
        .addEqualityGroup(Ordering.natural())
        .testEquals();
  }

  public void testIsInOrder() {
    assertFalse(Comparators.isInOrder(asList(5, 3, 0, 9), Ordering.natural()));

                return rx - lx;
            } else {
                return lx - rx;
            }
        };

        Map<String, Lifecycle> lifecyclesMap = lookupLifecycles();

        // ensure canonical order of standard lifecycles
        return lifecyclesMap.values().stream()
                .peek(l -> Objects.requireNonNull(l.getId(), "A lifecycle must have an id."))

    Helpers.testComparator(lexy, empty, a, aa, ab, b);

    new EqualsTester()
        .addEqualityGroup(lexy, Comparators.lexicographical(comparator))
        .addEqualityGroup(Comparators.lexicographical(String.CASE_INSENSITIVE_ORDER))
        .addEqualityGroup(Ordering.natural())
        .testEquals();
  }

  public void testIsInOrder() {
    assertFalse(Comparators.isInOrder(asList(5, 3, 0, 9), Ordering.natural()));

import java.util.Map;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * CompactLinkedHashMap is an implementation of a Map with insertion or LRU iteration order,
 * maintained with a doubly linked list through the entries. All optional operations (put and
 * remove) are supported. Null keys and values are supported.
 *

 * @see org.apache.maven.api.services.DependencyResolver
 */
@Experimental
@Immutable
public enum DependencyScope {

    /**
     * None. Allows you to declare dependencies (for example to alter reactor build order) but in reality dependencies
     * in this scope are not part of any path scope.
     */
    NONE("none", false),

    /**

@Named
@Singleton
public class DefaultProfileInjector implements ProfileInjector {

    private static final Map<Model, Map<List<Profile>, Model>> CACHE = Collections.synchronizedMap(new WeakHashMap<>());

    // In order for the weak hash map to work correctly, we must not hold any reference to
    // the model used as the key.  So we use a dummy model as a placeholder to indicate that
    // we want to store the model used as they key.

    // it.
    executeListener(runnable, executor);
  }

  /**
   * Runs this execution list, executing all existing pairs in the order they were added. However,
   * note that listeners added after this point may be executed before those previously added, and
   * note that the execution order of all listeners is ultimately chosen by the implementations of
   * the supplied executors.
   *

    @Override
    String id();

    /**
     * Collection of phases for this lifecycle
     */
    Collection<Phase> phases();

    /**
     * Pre-ordered list of phases.
     * If not provided, a default order will be computed.
     */
    default Optional<List<String>> orderedPhases() {
        return Optional.empty();
    }

    /**
     * A phase in the lifecycle.
     */
    interface Phase {