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

        problemCollector.add(Problem.Severity.ERROR, "MESSAGE", 3, 5, new Exception());
        ToolchainsBuildingException e = new ToolchainsBuildingException(problemCollector.getProblems());
        assertEquals(
                "1 problem was encountered while building the effective toolchains" + LS
                        + "[ERROR] MESSAGE @ line 3, column 5" + LS,
                e.getMessage());
    }

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

            connection.model(CustomModel)
                .addProgressListener(listener)
                .get()
        }


        then:
        def problems = getProblems()
        problems.size() == 0
    }

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

                typeValidationContext,
                extensionAddingVisitor
            );

            if (!typeValidationContext.getProblems().isEmpty()) {
                throw new DefaultMultiCauseException(
                    String.format(typeValidationContext.getProblems().size() == 1
                            ? "A problem was found with the %s plugin."

     *
     * @return The problems that caused this exception, never {@code null}.
     */
    public List<ModelProblem> getProblems() {
        if (result == null) {
            return Collections.emptyList();
        }
        return Collections.unmodifiableList(result.getProblems());
    }

    private static String toMessage(ModelBuildingResult result) {

        ProblemCollector collector2 = ProblemCollectorFactory.newInstance(Collections.singletonList(problem));

        assertNotSame(collector1, collector2);
        assertEquals(0, collector1.getProblems().size());
        assertEquals(1, collector2.getProblems().size());
    }