if (!remoteFile.exists()) {
                        download.setException(new ArtifactNotFoundException(download.getArtifact(), repository));
                    } else {
                        download.setException(new ArtifactTransferException(download.getArtifact(), repository, e));
                    }
                }
            }
        }
        if (metadataDownloads != null) {

        boolean pcdPresent = artifactDescriptorResult.getDependencies().stream()
                .filter(d -> "org.codehaus.plexus".equals(d.getArtifact().getGroupId()))
                .anyMatch(d -> "plexus-container-default".equals(d.getArtifact().getArtifactId()));

        if (pcdPresent) {
            pluginValidationManager.reportPluginValidationIssue(

     */
    AuthenticationInfo getAuthenticationInfo(String id);

    ProxyInfo getProxy(String protocol);

    void getArtifact(Artifact artifact, ArtifactRepository repository)
            throws TransferFailedException, ResourceDoesNotExistException;

    void getArtifact(Artifact artifact, List<ArtifactRepository> remoteRepositories)
            throws TransferFailedException, ResourceDoesNotExistException;

     */

    @Override
    public ResolutionNode resolveConflict(ResolutionNode node1, ResolutionNode node2) {
        try {
            ArtifactVersion version1 = node1.getArtifact().getSelectedVersion();
            ArtifactVersion version2 = node2.getArtifact().getSelectedVersion();

            return version1.compareTo(version2) <= 0 ? node1 : node2;
        } catch (OverConstrainedVersionException exception) {

            for (MavenProject reactorProject : session.getProjects()) {
                reactorProjects.put(
                        reactorProject.getArtifact(),
                        reactorProject.getArtifact().getFile());
            }

            Map<String, Artifact> map = new HashMap<>();
            for (Artifact artifact : resolvedArtifacts) {
                /**

                dependenciesValidator.validate(session, pluginArtifact, result);
            }

            pluginArtifact = result.getArtifact();

            if (logger.isWarnEnabled() && !result.getRelocations().isEmpty()) {
                String message =

            } else if (data instanceof ArtifactDescriptorRequest request) {
                return "artifact descriptor request for " + request.getArtifact();
            } else if (data instanceof ArtifactRequest request) {
                return "artifact request for " + request.getArtifact();
            } else if (data instanceof Plugin plugin) {
                return "plugin request " + plugin.getId();
            }

                new DefaultArtifact("com.example", "test", "consumer", "pom", "1.0.0") // consumer POM
                );
        request.setArtifacts(artifacts);
        return request;
    }

    private InstallRequest createInstallRequestWithConsumerPom() {
        InstallRequest request = new InstallRequest();
        List<Artifact> artifacts = List.of(

        this.project = project;

        artifact.setFile(project.getArtifact().getFile());
        artifact.setResolved(true);
    }

    /** {@inheritDoc} */
    @Override
    public File getFile() {
        // we need to get the latest file for the project, not the artifact that was created at one point in time
        return project.getArtifact().getFile();
    }

    /** {@inheritDoc} */
    @Override

                componentDescriptor.setRealm(pluginRealm);
            }

            pluginDescriptor.setClassRealm(pluginRealm);
            pluginDescriptor.setArtifacts(pluginArtifacts);
        } else {
            boolean v4api = pluginDescriptor.getMojos().stream().anyMatch(MojoDescriptor::isV4Api);