id("broken-task", "Task should not be called")
                    .contextualLabel("Task 'failingTask' should not be called")
                    .severity(Severity.ERROR)
                    .withException(RuntimeException("The 'failingTask' should not be called"))
                    .solution("Please use 'successfulTask' instead of this task")
            }
        }
    }

        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(),

            it.id('broken-task', 'Task should not be called')
                .contextualLabel("Task 'failingTask' should not be called")
                .severity(Severity.ERROR)
                .withException(new RuntimeException("The 'failingTask' should not be called"))
                .solution("Please use 'successfulTask' instead of this task")
        }
    }

        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()" : ""}

            }
            return FileDeletionResult.withException(original);
        }
    }

    protected static final class FileDeletionResult {

        static FileDeletionResult withoutException(boolean isSuccessful) {
            return new FileDeletionResult(isSuccessful, null);
        }

        static FileDeletionResult withException(Exception exception) {

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

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