* x
 *   indented
'''
        when:
        def result = parser.parse(classMetaData, listener)

        then:
        format(result.docbook).contains('x\n  indented')
    }

    def removesLeadingAsterixFromEachLine() {
        _ * classMetaData.rawCommentText >> ''' * line 1
 * line 2
'''
        when:
        def result = parser.parse(classMetaData, listener)

        then:

import org.junit.Test


class KotlinGrammarTest {

    @Test
    fun `will not parse empty annotation`() {
        kotlinGrammar.annotation.failToConsumeFrom("""@""")
        kotlinGrammar.annotation.failToConsumeFrom("""@ \n """)
    }

    @Test
    fun `will not parse @ followed by whitespace`() {
        kotlinGrammar.annotation.failToConsumeFrom("@ something")

                            )
                        )
                    )
                ]
            )""".trimIndent()
        parse(code).assert(expected)
    }

    private
    fun parse(code: String): LanguageTreeResult = ParseTestUtil.parse(code)

    }

    @Test
    fun `can parse tokens`() {
        val parser = combinator.token(KtTokens.OPEN_QUOTE)
        assertSuccess(parser("\""))
    }

    @Test
    fun `can parse string literals`() {
        val parser = combinator.stringLiteral
        assertSuccess(
            parser("\"foo\""),
            "foo"
        )
    }

    @Test
    fun `can parse integers`() {

            """
        )
        withFile("src/main/kotlin/SomeSource.kt", "fun main(args: Array<String>) {}")


        if (kotlinVersion >= VersionNumber.parse("1.6") && kotlinVersion < VersionNumber.parse("1.7")) {

                    </table>
                </section>
            </chapter>
        ''')

        def extraAttribute = new ExtraAttributeDoc(parse('<td>Extra column</td>'), parse('<td>some value</td>'))
        ClassDoc classDoc = classDoc('Class', content: content)

    }

    @Test
    fun `non-empty Stage 1 with empty Stage 2 parse to Stage 1`() {

        val source = programSourceWith(" buildscript { println(\"Stage 1\") } ")

        assertProgramOf(
            source,
            Program.Buildscript(source.fragment(1..11, 13..34))
        )
    }

    @Test
    fun `non-empty Stage 1 with non-empty Stage 2 parse to Stage 1 followed by Stage 2`() {

        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:

        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:

            )
        """.trimIndent()

        results.assert(expected)
    }

    @Test
    fun `parse infix function call with regular arguments`() {
        val results = parse(
            """
            f("a") g("b")
            """.trimIndent()
        )

        val expected = """