.id(MISSING_NORMALIZATION_ID.getName(), MISSING_NORMALIZATION_ID.getDisplayName(), MISSING_NORMALIZATION_ID.getGroup()) // TODO (donat) missing test coverage
                    .contextualLabel(String.format("is annotated with @%s but missing a normalization strategy", getAnnotationType().getSimpleName()))

        String text = Optional.ofNullable(problem.getContextualLabel()).orElseGet(() -> problem.getDefinition().getId().getDisplayName());
        return problem.toBuilder().contextualLabel(prefix + text).build();
    }

    private static boolean isTypeIrrelevantInErrorMessage(ProblemId problemId) {
        if (!problemId.getGroup().equals(GradleCoreProblemGroup.validation().property())) {

                .missing(unexpected)
                .includeLink()
        })

        verifyAll(receivedProblem(0)) {
            fqid == 'validation:property-validation:unexpected-input-file-type'
            contextualLabel == "Property \'input\' $fileType \'${unexpected.absolutePath}\' is not a $fileType"
            details == "Expected an input to be a $fileType but it was a ${getOppositeKind(fileType)}"
            solutions == [

                    .contextualLabel(String.format("has @ServiceReference annotation used on property of type '%s' which is not a build service implementation", typeVariables.get(0).getName()))

            problem.id(TextUtil.screamingSnakeToKebabCase(IMPLICIT_DEPENDENCY), "Property has implicit dependency", GradleCoreProblemGroup.validation().property()) // TODO (donat) missing test coverage
                .contextualLabel("Gradle detected a problem with the following location: '" + consumerProducerPath + "'")
                .documentedAt(userManual("validation_problems", IMPLICIT_DEPENDENCY.toLowerCase()))
                .severity(Severity.ERROR)

                throw problemReporter.throwing(problemSpec -> problemSpec
                    .id("groovy-daemon-compiler", "Missing tools.jar", GradleCoreProblemGroup.compilation().groovy())
                    .contextualLabel(contextualMessage)
                    .solution("Check if the installation is not a JRE but a JDK.")
                    .severity(Severity.ERROR)

                "configuration-cache-" + DeprecationMessageBuilder.createDefaultDeprecationId(message),
                message,
                GradleCoreProblemGroup.validation()
            )
            contextualLabel(message)
            documentOfProblem(problem)
            locationOfProblem(problem)
            severity(severity.toProblemSeverity())
        }.also { internalReporter.report(it) }
    }

    private

                    .id(getDefaultDeprecationIdDisplayName(usage), usage.getProblemIdDisplayName(), GradleCoreProblemGroup.deprecation())
                    .contextualLabel(usage.getSummary())
                    .details(usage.getRemovalDetails())
                    .documentedAt(usage.getDocumentationUrl())

                        .documentedAt(userManual("validation_problems", "cacheable_transform_cant_use_absolute_sensitivity"))
                        .contextualLabel("is declared to be sensitive to absolute paths")
                        .severity(ERROR)
                        .details("This is not allowed for cacheable transforms")

        });
    }

    private static void configureProblem(ProblemSpec spec, String message, String requestedPath, RuntimeException e) {
        spec.contextualLabel(message);
        spec.severity(Severity.ERROR);
        ((InternalProblemSpec) spec).additionalData(GeneralDataSpec.class, data -> data.put("requestedPath", Objects.requireNonNull(requestedPath)));