)
        """.trimIndent()

        results.assert(expected)
    }

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

        val expected = """

        TestHashCodes.hashCodeFrom(0x12345678) != null
        null != TestHashCodes.hashCodeFrom(0x12345678)
    }

    def "won't parse string with odd length"() {
        when:
        HashCode.fromString("a" * 9)

        then:
        thrown Exception
    }

    def "won't parse string with non-hex chars: #illegal"() {
        when:
        HashCode.fromString(illegal)

        then:

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

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

        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])

import org.intellij.lang.annotations.Language
import kotlin.test.assertEquals


class ParseTestUtil {

    companion object Parser {
        fun parse(@Language("kts") code: String): LanguageTreeResult {
            val parsedTree = org.gradle.internal.declarativedsl.parsing.parse(code)
            return DefaultLanguageTreeBuilder().build(parsedTree, SourceIdentifier("test"))
        }

 * 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:

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

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`() {