for (MethodLinkMetaData methodLinkMetaData : methods.values()) {
                message += "\n  " + methodLinkMetaData;
            }
            message += "\nThis problem may happen when some apilink from docbook template xmls refers to unknown method."
                    + "\nExample: <apilink class=\"org.gradle.api.Project\" method=\"someMethodThatDoesNotExist\"/>";
            throw new RuntimeException(message);

        1 * visitor.onEnd()
        0 * visitor._
    }

    def parsesJavadocTags() {
        when:
        lexer.pushText("{@tag some value}")
        lexer.visit(visitor)

        then:
        1 * visitor.onStartJavadocTag('tag')
        1 * visitor.onText('some value')
        1 * visitor.onEndJavadocTag('tag')
        1 * visitor.onEnd()
        0 * visitor._
    }

            )
        }
    }

    @Test
    fun `should fail if some method was upgraded but it was not actually changed`() {
        checkBinaryCompatibleFailsWithoutReport(
            v1 = {
                withFile(
                    "java/com/example/Task.java",

    }

    private List<String> filterChangesToReport(CtClass c, Map<String, CtClass> interfaces) {
        return interfaces.values().findAll { implementedDirectly(it, c) && addedInterfaceIsIncubatingOrInternal(it, c) }*.name.sort()
    }

    private boolean implementedDirectly(CtClass interf, CtClass c) {
        return c.interfaces.any { it.name == interf.name }
    }

is:
  java: {{ files | extensions | match(term='java') | every }}
  new: {{ source.diff.files | map(attr='original_file') | match(regex=r/^$/) | some }}

colors:

Not every module contributes to every runtime.

The core-runtime module defines each runtime:

- The target JVM for the runtime. Each runtime has its own JVM compatibility constraints.
- Some base services that are available to code hosted by the runtime. This varies by runtime.

        def versions = releasedVersions(snapshot, rc, finalVersionsBefore)
        def version = new ReleasedVersion('4.2', '20170913122310+0000')
        expect:
        def expectedVersions = (finalVersionsBefore + version).sort { it.version }.reverse()
        ******@****.***ReleasedVersions(version, versions) == releasedVersions(snapshot, rc, expectedVersions)
    }

    def "newer snapshots are stored"() {

        this._added = false

        makeArray(
            isString(pattern)
                ? splitPattern(pattern)
                : pattern
        ).forEach(this._addPattern, this)

        // Some rules have just added to the ignore,
        // making the behavior changed.
        if (this._added) {
            this._initCache()
        }

        return this
    }

    // legacy