class SomeOverriddenPrecompiledScript : Some {
                override fun something() {
                    println("precompiled overridden")
                }
            }

            SomePrecompiledScript().something()
            SomeOverriddenPrecompiledScript().something()
            """
        )
        withBuildScript(
            """
            import some.Some

        when:
        lexer.pushText("{@link <something> & &lt; </something>}")
        lexer.visit(visitor)

        then:
        1 * visitor.onStartJavadocTag('link')
        1 * visitor.onText('<something> & &lt; </something>')
        1 * visitor.onEndJavadocTag('link')
        1 * visitor.onEnd()
        0 * visitor._
    }

        sourceFile << """
#define SOME_STRING
"""

        then:
        macros == [unresolvedMacro('SOME_STRING')]
        macroFunctions.empty
    }

    def "finds object-like macro directive with empty body"() {
        when:
        sourceFile << """
#define SOME_STRING    // ignore
"""

        then:
        macros == [unresolvedMacro('SOME_STRING')]
        macroFunctions.empty
    }

* What went wrong:
something bad
> cause 1

* Try:
something

Failure 2:

* What went wrong:
something else bad
> cause 2

* Try:
something

"""
        when:
        def failure = OutputScrapingExecutionFailure.from(output, "")

        then:
        failure.assertHasCause("cause 1")
        failure.assertHasCause("cause 2")

        when:

			matches:   []string{"TestFoo/something/TestBaz"},
			nomatches: []string{"TestFoo", "TestFoo/TestBaz", "TestFoo/something/TestBar"},
		},
		{
			name:      "multiple",
			input:     []string{"TestFoo/subset", "TestBar"},
			matches:   []string{"TestBar", "TestBar/subtest", "TestFoo/subset"},
			nomatches: []string{"TestFoo/something/subset", "TestFoo/something", "TestFoo", "TestFoo/TestBar"},
		},
	}

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

class Item(BaseModel):
    name: str

    if PYDANTIC_V2:
        model_config = {
            "json_schema_extra": {
                "x-something-internal": {"level": 4},
            }
        }
    else:

        class Config:
            schema_extra = {
                "x-something-internal": {"level": 4},
            }


@app.get("/foo", response_model=Item)
def foo():
    return {"name": "Foo item"}

                new CaseSensitivityTestSpec(children, child, childIndex),
                new CaseSensitivityTestSpec(children, "$child/a/something", childIndex),
                new CaseSensitivityTestSpec(children, "$child/A/something", childIndex),
                new CaseSensitivityTestSpec(children, "$child/e/something", childIndex),
                new CaseSensitivityTestSpec(children, "$child/E/other", childIndex),
            ]
        }
    }

	// Call Add(1) before forking a goroutine, Add(-1) at the end of that goroutine.
	// Call Add(-1) just before waiting on something from another goroutine (e.g.,
	// just before a `select`).
	// Call Add(1) just before doing something that unblocks a goroutine that is
	// waiting on that something.
	Add(delta int)

    def localClassesDir = classesDir
    doLast {
        if (!localClassesDir.isDirectory()) {
            println 'The class directory does not exist. I can not operate'
            // do something
        }
        // do something
    }