@Test
    fun `will not parse @ followed by whitespace`() {
        kotlinGrammar.annotation.failToConsumeFrom("@ something")
        kotlinGrammar.annotation.failToConsumeFrom("@\nsomething")
        kotlinGrammar.annotation.failToConsumeFrom("@/*comment*/something")
        kotlinGrammar.annotation.failToConsumeFrom("@/*comment*/ something")
    }

    @Test
    fun `can parse single annotation`() {

            rootProject.name = 'other-build'
            include 'sub'
        """
        file('other-build/sub/build.gradle') << """
            tasks.register('doSomething') {
                doLast {
                    println 'do something'
                }
            }
        """

        when:
        toolingApi.withConnection { ProjectConnection connection ->

            rootProject.name = 'other-build'
            include 'sub'
        """
        file('other-build/sub/build.gradle') << """
            tasks.register('doSomething') {
                doLast {
                    println 'do something'
                }
            }
        """

        when:
        toolingApi.withConnection { ProjectConnection connection ->

        withConnection { ProjectConnection connection ->
            runBuildWithStandardInput(connection, 'something one', 'something two')
        }

        then:
        output.contains(FOO.prompt)
        output.contains(FOO.answerOutput('something one'))
        output.contains(BAR.prompt)
        output.contains(BAR.answerOutput('something two'))
    }

        !scriptData.hasMethods
    }

    def "method declarations are not considered imperative code"() {
        expect:
        def scriptData = parse("""def method() { println 'hi' }
private void doSomething() { thing = true }
""")
        !scriptData.runDoesSomething
        !scriptData.data.hasImperativeStatements
        scriptData.hasMethods
    }

go 1.18
-- test/file.go --
package test

func DoSomething() {
}
-- test2/go.mod --
module example.com/test2

go 1.18

replace example.com/test => ../test

require example.com/test v0.0.0-00010101000000-000000000000
-- test2/file.go --
package test2

import (
	"example.com/test"
)

func DoSomething() {
	test.DoSomething()
}
-- test2/sub/go.mod --
module example.com/test2/sub

                                      std::string* platform_name);

// This file implements core stream executor base classes in terms of
// the C API defined in stream_executor.h. A class "CSomething" represents a
// "Something" that can be manipulated via calls in the C interface.
class CPlatform : public Platform {
 public:
  explicit CPlatform(SP_Platform platform,
                     void (*destroy_platform)(SP_Platform*),

        ex << [
            new SocketException("something went wrong"),
            new SocketTimeoutException("something went wrong"),
            new HttpHostConnectException(new IOException("something went wrong"), null, null),
            new HttpErrorStatusCodeException("something", "something", 503, "something"),
            new RuntimeException("with cause", new SocketTimeoutException("something went wrong"))
        ]
    }

        settingsFile << "include 'child1'"
        buildFile """
def doSomething(def value) {
    return "{" + value + "}"
}
private String doSomethingElse(def value) {
    return "[" + value + "]"
}
println "root: " + doSomething(10)
println "root: " + doSomethingElse(10)
"""
        file("child1/build.gradle") << """
println "child: " + doSomething(11)
println "child: " + doSomethingElse(11)
"""

        expect:

		{path: "/logs", expected: true},
		{path: "/var/lib/something", expected: true},
		{path: "var/lib/something", expected: true},
		{path: "var\\lib\\something", expected: true},
		{path: "/", expected: true},
		{path: ".", expected: true},
		{path: "/var/../something", expected: false},
		{path: "/var//lib/something", expected: false},
		{path: "/var/./lib/something", expected: false},
	}