errMsg += " (You may need to remove the leading `javadoc` path component)";
                }
                errorsForFile.add(new Error(lineNumber, line, errMsg));
            }
            // TODO: Also parse the HTML in the javadoc file to check if the specific method is present
        }
    }

    private boolean fileContainsText(File referencedFile, String text) {
        try {

                    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

                sub.include("**/*.adoc");
                // Flatten adocs into a single directory
                sub.eachFile(fcd -> fcd.setRelativePath(RelativePath.parse(true, fcd.getName())));
            });

            // From the snippets and the samples, filter out files generated if the build contained was ever executed

        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 ?: [])
    }

                        }

                        BinaryCompatibilityHelper.setupJApiCmpRichReportRules(
                            this,
                            AcceptedApiChanges.parse("{acceptedApiChanges:[]}"),
                            rootProject.files("$sourceRoots"),
                            "2.0",
                            file("test-api-changes.json"),

        this.linkConverter = linkConverter;
    }

    public DocComment parse(ClassMetaData classMetaData, GenerationListener listener) {
        listener.start(String.format("class %s", classMetaData));
        try {
            String rawCommentText = classMetaData.getRawCommentText();
            try {
                return parse(rawCommentText, classMetaData, new NoOpCommentSource(), listener);
            } catch (Exception e) {

        }
    }

    private
    val List<String>.firstBaseVersion: String
        get() = VersionNumber.parse(first()).minorBaseVersion

    private
    val List<String>.lastBaseVersion: String
        get() = map { VersionNumber.parse(it) }
            .last { it.qualifier == null || it.qualifier?.startsWith("rc") == true }
            .minorBaseVersion

    private

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",

    @get:OutputDirectory
    abstract val receiptFolder: DirectoryProperty

    fun buildTimestampFrom(provider: Provider<String>) {
        buildTimestamp = provider.map { buildTimestampString -> timestampFormat.parse(buildTimestampString) }
    }

    @TaskAction
    fun generate() {
        if (promotionBuild.get()) {
            logger.logBuildVersion()
        }