@Override
    InternalProblemSpec details(String details);

    @Override
    InternalProblemSpec solution(String solution);

    @Override
    InternalProblemSpec withException(RuntimeException e);

    @Override
    InternalProblemSpec severity(Severity severity);

                     getProblems().forNamespace("org.example.plugin").reporting(problem -> problem
                            .id("type", "label")
                            .stackLocation()
                            .withException(new RuntimeException("Exception message", wrappedException))
                    );

                    // Write the current build operation id to a file

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

    ProblemSpec solution(String solution);

    /**
     * The exception causing this problem.
     *
     * @param e the exception.
     * @return this
     * @since 8.6
     */
    ProblemSpec withException(RuntimeException e);

    /**
     * Declares the severity of the problem.
     *
     * @param severity the severity
     * @return this
     * @since 8.6
     */

                    switch (deletionAction.apply(file)) {
                        case DeletionAction.EXCEPTION:
                            return DefaultDeleter.FileDeletionResult.withException(new Exception("ROOT CAUSE"))
                        case DeletionAction.FAILURE:
                            return DefaultDeleter.FileDeletionResult.withoutException(false)

        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:

            config.execute((U) additionalDatabuilder);
            additionalData = additionalDatabuilder.build();
        }
        return this;
    }

    @Override
    public InternalProblemBuilder withException(RuntimeException e) {
        this.exception = e;
        return this;
    }

    @Nullable
    RuntimeException getException() {
        return exception;
    }

                    .contextualLabel(contextualMessage)
                    .solution("Check if the installation is not a JRE but a JDK.")
                    .severity(Severity.ERROR)
                    .withException(new IllegalStateException(contextualMessage))
                );
            } else {
                languageGroovyClasspath = languageGroovyClasspath.plus(Collections.singletonList(toolsJar));
            }

        spec.severity(Severity.ERROR);
        ((InternalProblemSpec) spec).additionalData(GeneralDataSpec.class, data -> data.put("requestedPath", Objects.requireNonNull(requestedPath)));
        spec.withException(e);
    }

    private TaskSelector.SelectionContext sanityCheckPath(String name, String type) {
        // Don't allow paths that are:
        // - empty or blank
        // - the root path

            .contextualLabel(message)
            .lineInFileLocation(source.getFileName(), lineNumber)
            .severity(Severity.ERROR)
            .withException(new ScriptCompilationException(message, e, source, lineNumber))
        );
    }

    private static CompilerConfiguration createBaseCompilerConfiguration(Class<? extends Script> scriptBaseClass) {