expect:
        parse(source) == transformed

        where:
        source              | transformed
        "text<p>para 2</p>" | "<p>text</p><p>para 2</p>"
        "text<h2>text</h2>" | "<p>text</p><h2>text</h2>"
    }

    def "does not add implicit <p> element for elements with inline content"() {
        expect:
        parse(source) == transformed

        where:

        ClassDoc superType = classDoc("org.gradle.SuperType")
        ExtraAttributeDoc inheritedValue = new ExtraAttributeDoc(parse('<td>inherited</td>'), parse('<td>inherited</td>'))
        ExtraAttributeDoc overriddenValue = new ExtraAttributeDoc(parse('<td>general value</td>'), parse('<td>general</td>'))
        PropertyDoc inheritedPropertyA = propertyDoc('a', additionalValues: [inheritedValue, overriddenValue])

                    var result = [];
                    changeElements.each((idx, val) => result.push(JSON.parse(val.textContent)));
                    return result;
                }

                function appendErrorCorrections(reason) {
                    var result = JSON.parse('${currentApiChanges.replace('\n', '')}'); // JSON string from report uses double quotes, contain it within single quotes

                    jvmArgs '-Xmx1024m'
                    classpath = xslClasspath
                    systemProperty 'xslthl.config', xslthlConfigFile
                    systemProperty 'org.apache.xerces.xni.parser.XMLParserConfiguration', 'org.apache.xerces.parsers.XIncludeParserConfiguration'
                }
            }
        } as Runnable)
    }

    def parse(String str, Document document = null) {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance()
        factory.setNamespaceAware(true)
        DocumentBuilder builder = factory.newDocumentBuilder()
        def parsed = builder.parse(new InputSource(new StringReader(str))).documentElement
        return document ? document.importNode(parsed, true) : parsed
    }

import javax.xml.transform.stream.StreamResult
import org.w3c.dom.Document
import org.w3c.dom.Element
import org.w3c.dom.Node

class XIncludeAwareXmlProvider {

    Document root

    Element parse(File sourceFile) {
        root = parseSourceFile(sourceFile)
        root.documentElement
    }

    Node emptyDoc() {
        root = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument()
    }

    @Input
    abstract Property<String> getVersion();

    @TaskAction
    def transform() {
        XIncludeAwareXmlProvider provider = new XIncludeAwareXmlProvider()
        provider.parse(sourceFile.get().asFile)
        transformImpl(provider.document)
        provider.write(destFile.get().asFile)
    }

    private def transformImpl(Document doc) {
        use(BuildableDOMCategory) {

import com.google.gson.reflect.TypeToken
import org.gradle.util.GradleVersion

class AcceptedApiChanges {

    GradleVersion baseVersion
    Map<ApiChange, String> acceptedChanges

    static AcceptedApiChanges parse(String jsonText) {
        def acceptedApiChanges = new AcceptedApiChanges()
        def json = new Gson().fromJson(jsonText, new TypeToken<Map<String, List<AcceptedApiChange>>>() {}.type)

        then:
        format(link) == '<someLinkElement/>'
        _ * nameResolver.resolve('someName', classMetaData) >> 'org.gradle.SomeClass'
        _ * linkRenderer.link({it.name == 'org.gradle.SomeClass'}, listener) >> parse('<someLinkElement/>')
    }

    def convertsFullyQualifiedClassNameToLink() {
        when:
        def link = converter.resolve('org.gradle.SomeClass', classMetaData, listener)

        then:

        _ * property.signature >> "$name-signature"
        _ * javadocConverter.parse(property, !null) >> ({[parse("<para>${args.comment ?: 'comment'}</para>")]} as DocComment)
        return property
    }

    def propertyDoc(Map<String, ?> args = [:], String name) {
        return new PropertyDoc(classMetaData(), property(name, null), [parse("<para>$name comment</para>")], args.additionalValues ?: [])
    }