private final Problem problem;

    public DefaultProblemProgressDetails(Problem problem) {
        this.problem = problem;
    }

    public Problem getProblem() {
        return problem;
    }

     *
     * @since 1.1-rc-1
     */
    ModuleVersionSelector getSelector();

    /**
     * the exception that is the cause of unresolved state
     */
    Throwable getProblem();

    }

    @Override
    public void visitFailures(Consumer<Throwable> visitor) {
        for (UnresolvedDependency unresolvedDependency : unresolvedDependencies) {
            visitor.accept(unresolvedDependency.getProblem());
        }
        if (resolutionFailure != null) {
            visitor.accept(resolutionFailure);
        }
    }

    @Override
    public MinimalResolutionResult getResolutionResult() {

        this.selector = selector;
        this.problem = problem;
    }

    @Override
    public ModuleVersionSelector getSelector() {
        return selector;
    }

    @Override
    public Throwable getProblem() {
        return problem;
    }

    @Override
    public String toString() {
        return selector.getGroup() + ":" + selector.getName() + ":" + selector.getVersion();
    }

    def "visits all resolution failures"() {
        given:
        def throwable = Mock(Throwable)
        def resolveEx = Mock(ResolveException)

        def unresolved = Mock(UnresolvedDependency) {
            getProblem() >> throwable
        }

        def results1 = new DefaultVisitedGraphResults(resolutionResult, Collections.emptySet(), null)

                ComponentSelectionReasons.of(DEPENDENCY_LOCKING),
                new ModuleVersionResolveException(failureComponentSelector, () -> "Dependency lock state out of date", failure.getProblem())));
        }
    }

        assertNotNull(collector.getProblems());
        assertEquals(0, collector.getProblems().size());

        collector.add(null, "MESSAGE1", -1, -1, null);

        Exception e2 = new Exception();
        collector.add(Severity.WARNING, null, 42, 127, e2);

        assertEquals(2, collector.getProblems().size());

        Problem p1 = collector.getProblems().get(0);

        """
            import org.gradle.api.problems.Severity

            abstract class ProblemReportingTask extends DefaultTask {
                @Inject
                protected abstract Problems getProblems();

                @TaskAction
                void run() {
                    $taskActionMethodBody
                }
            }

            tasks.register("reportProblem", ProblemReportingTask)

        }

        @Override
        public Collection<Problem> getProblems() {
            return getProblems(buildFailure);
        }

        @Override
        public Collection<Problem> getProblemsFor(Throwable failure) {
            return problems.get(buildFailure);
        }

        private @Nonnull Collection<Problem> getProblems(@Nullable Throwable buildFailure) {

    public static <T> Result<T> error(Result<?> result) {
        return error(result.getProblems());
    }

    public static <T> Result<T> error(Result<?>... results) {
        final List<ModelProblem> problemsList = new ArrayList<>();

        for (Result<?> result1 : results) {
            for (ModelProblem modelProblem : result1.getProblems()) {
                problemsList.add(modelProblem);
            }
        }