return validateDelegate(delegate.additionalData(specType, config));
    }

    @Override
    public InternalProblemBuilder withException(RuntimeException e) {
        return validateDelegate(delegate.withException(e));
    }

    @Override
    public InternalProblemBuilder severity(Severity severity) {
        return validateDelegate(delegate.severity(severity));
    }

        given:
        withReportProblemTask """
            problems.forNamespace('org.example.plugin').reporting {
                it.id('type', 'label')
                .withException(new RuntimeException("test"))
            }
        """

        when:
        run('reportProblem')

        then:
        verifyAll(receivedProblem) {
            exception.message == 'test'

                configureProblem(spec, matcher, context);
                String message = matcher.formatErrorMessage("Task", searchContext);
                spec.contextualLabel(message)
                    .withException(new TaskSelectionException(message));
            });
        }
        String message = String.format("Cannot locate %s that match '%s' as %s", context.getType(), context.getOriginalPath(),

        buildFile """
            ${getProblemReportingScript """
                problems.forNamespace('org.example.plugin').throwing {
                    it.id('type', 'label')
                    .withException(new RuntimeException('failed'))
            }"""}

            task $succeedingTaskName
        """
    }

    def "end of build listener is notified on success"() {
        when:

    @Override
    <U extends AdditionalDataSpec> InternalProblemBuilder additionalData(Class<? extends U> specType, Action<? super U> config);

    @Override
    InternalProblemBuilder withException(RuntimeException e);

    @Override
    InternalProblemBuilder severity(Severity severity);

                        it.${targetVersion < GradleVersion.version("8.8") ? 'label("label").category("testcategory")' : 'id("testcategory", "label")'}
                            .withException(new RuntimeException("test"))
                            ${pre86api ? ".undocumented()" : ""}

        DefaultProblemBuilder problemBuilder = new DefaultProblemBuilder(problemStream);
        spec.execute(problemBuilder);
        problemBuilder.withException(e);
        throw throwError(e, problemBuilder.build());
    }

    @Override
    public Problem create(Action<InternalProblemSpec> action) {

    @Override
    InternalProblemSpec details(String details);

    @Override
    InternalProblemSpec solution(String solution);

    @Override
    InternalProblemSpec withException(RuntimeException e);

    @Override
    InternalProblemSpec severity(Severity severity);

        spec.severity(Severity.ERROR);
        spec.id("initialization-failed", "Java compilation initialization error", GradleCoreProblemGroup.compilation().java());
        spec.details(ex.getLocalizedMessage());
        spec.withException(ex);
    }

        given:
        def problem = problemReporter.create {
            it.id("id", "label", GradleCoreProblemGroup.validation())
                .withException(new RuntimeException("cause"))
        }

        when:
        def json = gson.toJson([problem])
        def deserialized = ValidationProblemSerialization.parseMessageList(json)

        then: