*/
@Deprecated(since = "4.0.0")
public class DefaultDependencyResolutionRequest implements DependencyResolutionRequest {

    private MavenProject project;

    private DependencyFilter filter;

    private RepositorySystemSession session;

    public DefaultDependencyResolutionRequest() {
        // enables default constructor
    }

 * local or remote repositories.
 */
public class MultipleArtifactsNotFoundException extends ArtifactResolutionException {
    private static final String LS = System.lineSeparator();

    private final List<Artifact> resolvedArtifacts;
    private final List<Artifact> missingArtifacts;

    /**
     * @param originatingArtifact the artifact that was being resolved

    private static final String GROUP_ID = "test";

    // fields -----------------------------------------------------------------

    protected Artifact a1;

    protected Artifact a2;

    protected Artifact b1;

    private final String roleHint;

    @Inject
    private ArtifactFactory artifactFactory;

    private ConflictResolver conflictResolver;

    @Inject

@Named
@Singleton
public class DefaultTypeRegistry extends AbstractEventSpy implements TypeRegistry {
    private final Lookup lookup;

    private final LanguageRegistry languageRegistry;

    private final ConcurrentHashMap<String, Type> usedTypes;

    private final LegacyArtifactHandlerManager manager;

    @Inject

import org.codehaus.plexus.configuration.PlexusConfiguration;

public class ExtensionConfigurationModule implements Module {

    private final CoreExtensionEntry extension;
    private final UnaryOperator<String> callback;

    private final DefaultInterpolator interpolator = new DefaultInterpolator();

    public ExtensionConfigurationModule(CoreExtensionEntry extension, UnaryOperator<String> callback) {

 * This logger is used in case of "early failures" (when no logging may be set up yet).
 */
public class SystemLogger implements Logger {
    private final PrintWriter out;
    private final Level threshold;

    public SystemLogger(@Nullable OutputStream out) {
        this(out, null);
    }

    public SystemLogger(@Nullable OutputStream out, @Nullable Level threshold) {

     * rely on the class node analysis since it doesn't give the right superclass because
     * resolution is not complete when this visitor is executed.
     */
    private boolean isIntegrationTest(ClassNode current) {
        return current.getName().endsWith("Test") || current.getName().endsWith("Spec");
    }

    @Override
    protected boolean shouldVisitMethod(MethodNode node) {

import org.codehaus.plexus.component.repository.exception.ComponentLookupException;

/**
 */
public class PluginConfigurationException extends Exception {
    private PluginDescriptor pluginDescriptor;

    private String originalMessage;

    public PluginConfigurationException(PluginDescriptor pluginDescriptor, String originalMessage) {
        super(originalMessage);

/**
 * DefaultBuildPluginManager
 */
@Named
@Singleton
public class DefaultBuildPluginManager implements BuildPluginManager {

    private final MavenPluginManager mavenPluginManager;
    private final LegacySupport legacySupport;
    private final MojoExecutionScope scope;
    private final MojoExecutionListener mojoExecutionListener;

    @Inject
    public DefaultBuildPluginManager(

import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertTrue;

@PlexusTest
@Deprecated
class MirrorProcessorTest {
    @Inject
    private DefaultMirrorSelector mirrorSelector;

    @Inject
    private ArtifactRepositoryFactory repositorySystem;

    @Test
    void testExternalURL() {
        assertTrue(DefaultMirrorSelector.isExternalRepo(getRepo("foo", "http://somehost")));