private final Problem problem;

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

    public Problem getProblem() {
        return problem;
    }

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

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

        """
            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) {

                .addProgressListener(listener)
                .get()
        }
        def problems = getProblems()

        then:
        problems.size() == 0

        where:
        javaHome << [
            jdk8,
            jdk17,
            jdk21
        ]
    }

    List<Object> getProblems() {
        listener.problems.collect { it.descriptor }
    }

    def "Can add additional metadata"() {

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