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

        if (details instanceof DefaultProblemProgressDetails) {
            Problem problem = ((DefaultProblemProgressDetails) details).getProblem();
            return Optional.of(createProblemEvent(buildOperationId, problem));
        }
        return empty();
    }

                norm(it)
            }
        }

        String getArtifactTooltip() {
            row.select("td > div[uk-tooltip]").attr("uk-tooltip") - 'title: '
        }

        String getProblem() {
            if (problems.size() != 1) {
                throw new AssertionError("Expected a single problem but there were ${problems.size()}")
            }
            problems[0]
        }
    }

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

        ToolchainsBuildingResult result = toolchainBuilder.build(request);
        assertNotNull(result.getEffectiveToolchains());
        assertNotNull(result.getProblems());
        assertEquals(0, result.getProblems().size());
    }

    @Test
    void testBuildRequestWithUserToolchains() throws Exception {
        Properties props = new Properties();
        props.put("key", "user_value");