}

    public ArtifactTransferResource getResource() {
        return artifact;
    }

    /**
     * @return Returns the exception.
     */
    public Exception getException() {
        return exception;
    }

    /**
     * Returns the request type.
     *
     * @return Returns the request type. The Request type is one of

                                "Failed to process POM for " + artifact.getId() + ": " + missingParentPom.getMessage(),
                                missingParentPom.getException(),
                                artifact);
                    }

                    String message;

                    if (isMissingPom(e)) {

            assertEquals(1, ((Collection) result.getProblems()).size());
            result.getProblems().forEach(p -> {
                assertTrue(expectedException.isInstance(p.getException()));
                assertTrue(p.getException().getMessage().contains(partOfMessage));
            });
        }
    }

    @Test
    void testProcessPackagingAttribute() throws ProjectBuildingException {

        TransferResource resource = event.getResource();
        // TODO This needs to be colorized
        out.println("[WARNING] " + event.getException().getMessage() + " from " + resource.getRepositoryId() + " for "
                + resource.getRepositoryUrl() + resource.getResourceName());
    }

    @Override

                            .filter(projectsOutsideOfRequestScope)
                            .flatMap(projectBuildingResult -> projectBuildingResult.getProblems().stream())
                            .map(ModelProblem::getException)
                            .filter(pluginArtifactNotFoundException)
                            .map(exc -> ((PluginResolutionException) exc.getCause()).getPlugin())

                    if (logger.isDebugEnabled()) {
                        for (SettingsProblem problem : result.getProblems()) {
                            logger.debug(problem.getMessage(), problem.getException());
                        }
                    }

                    Authentication authentication = new Authentication(server.getUsername(), server.getPassword());

                versionIndex.put(version, workspace.getRepository());
            }
        }

        for (MetadataResult metadataResult : metadataResults) {
            result.addException(metadataResult.getException());

            ArtifactRepository repository = metadataResult.getRequest().getRepository();
            if (repository == null) {
                repository = session.getLocalRepository();
            }

                        .flatMap(r -> r.getProblems().stream())
                        .filter(p -> p.getException() instanceof CycleDetectedException)
                        .findAny()
                        .orElse(null);
                if (cycle != null) {
                    final CycleDetectedException cde = (CycleDetectedException) cycle.getException();
                    throw new ProjectBuildingException(
                            null,

            if (!location.isEmpty()) {
                message += " @ " + location;
            }

            return handle(message, problem.getException());
        } else {
            return null;
        }
    }

    private String getReference(Set<Throwable> dejaVu, Throwable exception) {
        String reference = "";

                }
                model = modelResult.getEffectiveModel();
            } catch (ModelBuildingException e) {
                for (ModelProblem problem : e.getProblems()) {
                    if (problem.getException() instanceof UnresolvableModelException unresolvableModelException) {
                        result.addException(unresolvableModelException);
                        throw new ArtifactDescriptorException(result);