then:
        failureDescriptionContains(
            incompatibleAnnotations {
                type('TaskWithInputs').property('input')
                annotatedWith('IgnoreEmptyDirectories')
                incompatibleWith(nonDirectoryInput.annotation - '@')
                includeLink()
            }
        )

        where:
        nonDirectoryInput << NonDirectoryInput.values()
    }

        String annotatedWith
        String incompatibleWith

        IncompatibleAnnotations(ValidationMessageChecker checker) {
            super(checker)
        }

        IncompatibleAnnotations annotatedWith(String name) {
            annotatedWith = name
            this
        }

        IncompatibleAnnotations incompatibleWith(String name) {
            incompatibleWith = name
            this
        }

    def "tests output of incompatibleAnnotations"() {
        when:
        render incompatibleAnnotations {
            type('SuperHero').property('fireballs')
            annotatedWith("Boring")
            incompatibleWith("SuperPower")
            includeLink()
        }

        then:
        outputEquals """
Type 'SuperHero' property 'fireballs' is annotated with @Boring but that is not allowed for 'SuperPower' properties.

                missingValueMessage { property('incrementalNonFileInput').includeLink().noIntro() },
                incompatibleAnnotations { property('incrementalNonFileInput').annotatedWith('Incremental').incompatibleWith('Input').includeLink().noIntro() },
            ],
            missingInput: missingValueMessage { property('missingInput').includeLink().noIntro() },

            error(incompatibleAnnotationsConfig { type('MyTransformParameters').property('incrementalNonFileInput').annotatedWith('Incremental').incompatibleWith('Input') }, 'validation_problems', 'incompatible_annotations'),

    find { it.isCompatibleWith(api) } != null


private
fun KCallable<*>.isCompatibleWith(api: KCallable<*>) =
    when (this) {
        is KFunction -> isCompatibleWith(api)
        is KProperty -> isCompatibleWith(api)
        else -> false
    }


private
fun KProperty<*>.isCompatibleWith(api: KCallable<*>) =
    this::class == api::class

    public boolean isJava5Compatible() {
        return isCompatibleWith(VERSION_1_5);
    }

    public boolean isJava6Compatible() {
        return isCompatibleWith(VERSION_1_6);
    }

    public boolean isJava7Compatible() {
        return isCompatibleWith(VERSION_1_7);
    }

    public boolean isJava8Compatible() {
        return isCompatibleWith(VERSION_1_8);
    }

            .withClassLoaderStructure(new HierarchicalClassLoaderStructure(spec1).withChild(spec2))
            .keepAliveMode(KeepAliveMode.SESSION)
            .build()

        expect:
        settings.isCompatibleWith(settings)
    }

    def "is compatible with same settings"() {
        def spec1 = Mock(ClassLoaderSpec)
        def spec2 = Mock(ClassLoaderSpec)
        def settings1 = daemonForkOptionsBuilder()

        then:
        options.isCompatibleWith(other)
    }

    def "is compatible with a subset of jvm args"() {
        def other = new DefaultJavaForkOptions(resolver, fileCollectionFactory, new DefaultJavaDebugOptions())

        when:
        options.jvmArgs = ["-server", "-esa"]
        other.jvmArgs = ["-server"]

        then:
        options.isCompatibleWith(other)
    }

            return VersionCoverage.versionsAtLeast(SCALA_3, "3.3.4")
        }
        if (javaVersion.isCompatibleWith(JavaVersion.VERSION_20)) {
            return VersionCoverage.versionsAtLeast(SCALA_3, "3.3.0")
        }
        if (javaVersion.isCompatibleWith(JavaVersion.VERSION_19)) {
            return VersionCoverage.versionsAtLeast(SCALA_3, "3.2.2")
        }