if (graphResult.hasErrors()) {
            return addExceptionToResult(
                    result, graphResult.getProblems().iterator().next().getException());
        }

        try {
            session.setProjectMap(getProjectMap(session.getProjects()));
        } catch (DuplicateProjectException e) {
            return addExceptionToResult(result, e);

        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())

            return expiration;
        }

        @Override
        public void setExpiration(Long exp) {
            this.expiration = exp;
        }

        @Override
        public Exception getException() {
            return exception;
        }

        @Override
        public void exception(Exception e) {
            this.exception = e;
        }

        // Methods from Message interface

            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 {

            if ((i == lines.length - 1)
                    && (context.options().showErrors().orElse(false)
                            || (summary.getException() instanceof InternalErrorException))) {
                context.logger.error(line, summary.getException());
            } else {
                context.logger.error(line);
            }

            currentColor = nextColor;
        }

        void testExceptionState() {
            Exception testException = new RuntimeException("Test error");

            assertNull(testBlock.getException());

            testBlock.exception(testException);
            assertEquals(testException, testBlock.getException());
        }

        @Test
        @DisplayName("Test error state")
        void testErrorState() {
            assertFalse(testBlock.isError());

            Map<String, VersionInfo> infos = new HashMap<>();

            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 (logger.isDebugEnabled()) {
                        for (SettingsProblem problem : result.getProblems()) {
                            logger.debug(problem.getMessage(), problem.getException());
                        }
                    }

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