inCatalog('libs')
            missing(path)
        })

        and:
        verifyAll(receivedProblem) {
            fqid == 'dependency-version-catalog:catalog-file-does-not-exist'
            contextualLabel == 'Problem: In version catalog libs, import of external catalog file failed.'
            details == "File \'${file('missing.toml').absolutePath}\' doesn\'t exist"

            .forProperty(annotationMetadata.getPropertyName())
            .id(TextUtil.screamingSnakeToKebabCase(missingAnnotation), "Missing annotation", GradleCoreProblemGroup.validation().property())
            .contextualLabel("is missing " + displayName)
            .documentedAt(userManual("validation_problems", TextUtil.toLowerCaseLocaleSafe(missingAnnotation)))
            .severity(ERROR)

        result.outputPropertyNames == null

        and:
        verifyAll(receivedProblem(0)) {
            fqid == 'validation:property-validation:unknown-implementation'
            contextualLabel == 'Additional action of task \':customTask\' was loaded with an unknown classloader (class \'CustomTask_Decorated\').'
            details == 'Gradle cannot track the implementation for classes loaded with an unknown classloader.'

            problem.withAnnotationType(classWithAnnotationAttached)
                .id("invalid-use-of-type-annotation", "Incorrect use of type annotation", GradleCoreProblemGroup.validation().type())
                .contextualLabel("is incorrectly annotated with @" + annotationType.getSimpleName())
                .documentedAt(Documentation.userManual("validation_problems", "invalid_use_of_cacheable_annotation"))
                .severity(Severity.ERROR)

                        .id("mismatched-types-for-software-type", "has @SoftwareType annotation used on property", GradleCoreProblemGroup.validation().property())
                        .contextualLabel(String.format("has @SoftwareType annotation with public type '%s' used on property of type '%s'", ModelType.of(publicType).getDisplayName(), ModelType.of(valueType).getDisplayName()))
                        .severity(Severity.ERROR)

    }

    private static ContextualLabel toContextualLabel(@Nullable InternalContextualLabel contextualLabel) {
        return new DefaultContextualLabel(contextualLabel == null ? null : contextualLabel.getContextualLabel());
    }

    private static ContextualLabel toContextualLabel(@Nullable String contextualLabel) {
        return new DefaultContextualLabel(contextualLabel);
    }

                                        id("invalid-dependency", "Property cannot carry dependency", GradleCoreProblemGroup.validation().property())
                                        contextualLabel("Property '$propertyName' cannot carry a dependency on $dependency as these are not yet supported.")
                                        severity(Severity.ERROR)
                                    })

                        .id(TextUtil.screamingSnakeToKebabCase(UNSUPPORTED_VALUE_TYPE), "Unsupported value type", GradleCoreProblemGroup.validation().property())
                        .contextualLabel(
                            String.format(
                                "has @%s annotation used on property of type '%s'",
                                annotationType.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())) {

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