given:
        def called = false
        String thing = "1"
        def closure = { ->
            called = true
            assert delegate.is(thing)
        }

        when:
        action(closure).execute(thing, [])

        then:
        called
    }

    def "can construct with empty arg closure"() {
        given:
        def called = false
        String thing = "1"

=== "Python 3.8+"

    ```Python hl_lines="22"
    {!> ../../../docs_src/body_multiple_params/tutorial002.py!}
    ```

In diesem Fall wird **FastAPI** bemerken, dass es mehr als einen Body-Parameter in der Funktion gibt (zwei Parameter, die Pydantic-Modelle sind).

Es wird deshalb die Parameternamen als Schlüssel (Feldnamen) im Body verwenden, und erwartet einen Body wie folgt:

```JSON
{
    "item": {
        "name": "Foo",

        }
"""
        expect:
        fails("check")
        failure.assertHasCause("Invalid rulesMinimumPriority '11'.  Valid range 1 (highest) to 5 (lowest).")
    }

    def "can configure reporting"() {
        goodCode()
        buildFile << """
            pmdMain {
                reports {
                    xml.required = false
                    html.outputLocation = file("htmlReport.html")

    @ToBeFixedForConfigurationCache(because = "Does actually write the lock file when CC is enabled (which is fine, because all dependency resolution has completed successfully by the time the task fails)")
    def 'does not write lock file when task execution fails'() {
        mavenRepo.module('org', 'bar', '1.1').publish()

        buildFile << """
dependencyLocking {
    lockAllConfigurations()
}

repositories {
    maven {

        """
        when:
        fails()

        then:
        failure.assertHasCause("Cannot change usage of dependency configuration ':a' after it has been resolved")

        where:
        role                      | code
        'consume or publish only' | 'configurations.a.canBeResolved = false'
        'query or resolve only'   | 'configurations.a.canBeConsumed = false'

    }

    def 'subsequent execution runs failed test first'() {
        given:
        letTestFail(indexOfTestToFail)

        when:
        fails('test', '--info')

        then:
        testFailed(indexOfTestToFail)

        when:
        fails('test', '--info')

        then:
        failedTestAreRerunFirst(indexOfTestToFail)

        when:
        letTestFail(0)
        succeeds('test')

        (findRequiredKeystoreFile(false) != null) == keystoreExpected

        where:
        kind                    | enabled   | keystoreExpected
        EncryptionKind.NONE     | false     | false
        EncryptionKind.KEYSTORE | true      | true
        EncryptionKind.ENV_VAR  | true      | false
    }

    private boolean isFoundInDirectory(File startDir, byte[] toFind) {

        withFile(
            "external-plugins/src/main/kotlin/applied-output-fails.gradle.kts", """
            ${outputFrom("applied-output-fails plugin")}
            TODO("applied-output-fails plugin application failure")
        """
        )

        withDefaultSettings().appendText("""includeBuild("external-plugins")""")

        def message = "Name 'class1' must match pattern"

        given:
        defaultLanguage('en')
        badCode()
        fails("check")
        failure.assertHasErrorOutput(message)

        when:
        buildFile << "checkstyle { showViolations = false }"
        fails("check")

        then:
        failure.assertHasDescription("Execution failed for task ':checkstyleMain'.")

    !!! tip "Tipp"
        Bevorzugen Sie die `Annotated`-Version, falls möglich.

    ```Python hl_lines="7"
    {!> ../../../docs_src/query_params_str_validations/tutorial003_py310.py!}
    ```

=== "Python 3.8+ nicht annotiert"

    !!! tip "Tipp"
        Bevorzugen Sie die `Annotated`-Version, falls möglich.

    ```Python hl_lines="10"