final JavadocLinkConverter converter = new JavadocLinkConverter(document, nameResolver, linkRenderer, repository)

    def convertsClassNameToLink() {
        when:
        def link = converter.resolve('someName', classMetaData, listener)

        then:
        format(link) == '<someLinkElement/>'
        _ * nameResolver.resolve('someName', classMetaData) >> 'org.gradle.SomeClass'

        format(link) == '<classname>boolean</classname>'
    }

    def rendersLinkToGroovyClass() {
        when:
        def link = renderer.link(type('groovy.lang.Closure'), listener)

        then:
        format(link) == '<ulink url="https://docs.groovy-lang.org/groovyVersion/html/gapi/groovy/lang/Closure.html"><classname>Closure</classname></ulink>'
    }

    def rendersLinkToGroovyClassArray() {
        when:

        when:
        def p = propertyMetaData.overriddenProperty

        then:
        p == null
    }

    def hasNoOverriddenPropertyWhenGetterAndSetterDoNotOverrideAnything() {
        when:
        def p = propertyMetaData.overriddenProperty

        then:
        p == null
    }

    def "is deprecated when @Deprecated is attached to property"() {

        when:
        LinkMetaData linkMetaData = classLinkMetaData.getMethod("$METHOD_NAME()")

        then:
        linkMetaData != null
        linkMetaData.style == LinkMetaData.Style.Javadoc
        linkMetaData.displayName == "$SIMPLE_CLASSNAME.${METHOD_NAME}()"
        linkMetaData.urlFragment == "$METHOD_NAME--"

        when:

 */

package gradlebuild.binarycompatibility

import spock.lang.Specification

class AcceptedApiChangesTest extends Specification {

    def "parses accepted change"() {
        when:
        def changes = AcceptedApiChanges.parse("""
            {
                "acceptedApiChanges": [
                    {
                        "type": "org.gradle.api.initialization.ConfigurableIncludedBuild",

        when:
        newBase.addInterface(stablePublicInterface)

        then:
        noViolation(rule)
    }

    def 'adding an #type interface can be reported'() {
        given:
        newBase.addInterface(interfaces[type])

        when:
        Violation violation = rule.maybeViolation(apiClass)

        then:
        violation.humanExplanation.contains(result)

</section>
''')

        when:
        ClassDoc doc = withCategories {
            def doc = new ClassDoc('org.gradle.Class', content, document, classMetaData, null)
            doc.superClass = superDoc
            doc.interfaces << superType1
            doc.interfaces << superType2
            builder.build(doc)
            return doc
        }

        then:
        doc.classProperties.size() == 5

object KotlinMetadataQueries {

    fun isKotlinFileFacadeClass(ctClass: CtClass): Boolean =
        if (Modifier.isPrivate(ctClass.modifiers)) false
        else queryKotlinMetadata(ctClass, false) { metadata ->
            when (metadata) {
                is KotlinClassMetadata.FileFacade -> true
                else -> false
            }
        }

    fun isKotlinInternal(ctClass: CtClass): Boolean =

    def "is deprecated when @Deprecated annotation is attached to class"() {
        def notDeprecated = new ClassMetaData("SomeClass")
        def deprecated = new ClassMetaData("SomeClass")
        deprecated.addAnnotationTypeName(Deprecated.class.name)

        expect:
        !notDeprecated.deprecated
        deprecated.deprecated
    }

    def "is incubating when @Incubating annotation is attached to class"() {

    override fun getDisplayName(): String =
        "the build timestamp extracted from the build receipt".let {
            when {
                parameters.ignoreIncomingBuildReceipt.get() -> "$it (ignored)"
                else -> it
            }
        }

    private
    fun Parameters.buildReceiptString(): String? = when {
        ignoreIncomingBuildReceipt.get() -> null
        else -> buildReceiptFileContents.orNull
    }