* If plugin or extension needs anything more complex feature wise (i.e. HTTP range support or alike) it should
 * probably roll its own.
 * <p>
 * This implementation is backed by Maven Resolver API, supported protocols and transport selection depends on it. If
 * resolver preference regarding transport is altered, it will affect this service as well.
 *
 * @since 4.0.0
 */

    void flush();

    /**
     * Registers the specified cache record for usage with the given project. Integrators can use the information
     * collected from this method in combination with a custom cache implementation to dispose unused records from the
     * cache.
     *
     * @param project The project that employs the plugin realm, must not be {@code null}.

import java.util.HashSet;
import java.util.Set;

/**
 * Filter to only retain objects in the given scope or better. This implementation allows the accumulation of multiple
 * scopes and their associated implied scopes, so that the user can filter apply a series of implication rules in a
 * single step. This should be a more efficient implementation of multiple standard {@link ScopeArtifactFilter}
 * instances ORed together.
 *
 */

import org.eclipse.aether.repository.WorkspaceRepository;
import org.eclipse.aether.util.artifact.ArtifactIdUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * An implementation of a workspace reader that knows how to search the Maven reactor for artifacts, either as packaged
 * jar if it has been built, or only compile output directory if packaging hasn't happened yet.
 *
 */

import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;

/**
 * Test cases for the project {@code ModelResolver} implementation.
 *
 * @since 3.5.0
 */
class ProjectModelResolverTest extends AbstractMavenProjectTestCase {

    /**
     * Creates a new {@code ProjectModelResolverTest} instance.
     */

 * {@link #TEST_COMPILE} and {@link #TEST_RUNTIME}, but can be extended by registering a
 * {@code org.apache.maven.api.spi.PathScopeProvider}.
 * <p>
 * Implementation must have {@code equals()} and {@code hashCode()} implemented, so implementations of this interface
 * can be used as keys.
 *
 * @since 4.0.0
 * @see org.apache.maven.api.services.DependencyResolver
 * @see DependencyScope
 */
@Experimental

 * under the License.
 */
package org.apache.maven.building;

import java.util.List;

/**
 *
 * @since 3.3.0
 */
public class ProblemCollectorFactory {

    /**
     * The default implementation is not visible, create it with this factory
     *
     * @param problems starting set of problems, may be {@code null}
     * @return a new instance of a ProblemCollector
     */

import javax.inject.Named;
import javax.inject.Singleton;

/**
 * The default conflict resolver that delegates to the nearest strategy.
 *
 * @see NearestConflictResolver
 * @deprecated As of 3.0, use a specific implementation instead, e.g. {@link NearestConflictResolver}
 */
@Deprecated
@Named
@Singleton

 * leveraged using the {@link org.apache.maven.api.plugin.annotations.Execute}
 * annotation.  If a {@code META-INF/maven/lifecycle.xml} file is packaged
 * in the plugin, Maven will provide a default implementation that will parse
 * the file and return the contained lifecycle definitions.
 *
 * @since 4.0.0
 */
@Experimental
@Consumer
public interface LifecycleProvider {

    List<Lifecycle> getLifecycles();

/**
 * Caches auxiliary data used during model building like already processed raw/effective models. The data in the cache
 * is meant for exclusive consumption by the model builder and is opaque to the cache implementation. The cache key is
 * formed by a combination of group id, artifact id, version and tag. The first three components generally refer to the