assert event.descriptor.displayName == 'some build'
            assert event.descriptor.parent == null
        }
    }

    def "convert to BuildStartEvent"() {
        given:
        def listener = Mock(ProgressListener)
        def adapter = createAdapter(listener)

        when:
        def buildDesc = buildDescriptor(666, 'some build')

        given:
        def output = """
Some message

FAILURE: broken

* Exception is:
Some.Failure
"""
        def errorOutput = """
Some error
"""

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

        then:
        failure.assertOutputContains("Some message")
        failure.assertHasErrorOutput("Some error")

        when:

        given:
        projectLayoutRegistry.get("some-type") >> defaultGenerator
        defaultGenerator.id >> "some-type"
        defaultGenerator.modularizationOptions >> [ModularizationOption.SINGLE_PROJECT]
        defaultGenerator.dsls >> [KOTLIN]
        defaultGenerator.getTestFrameworks(_) >> [NONE, JUNIT]
        init.type = "some-type"
        init.testFramework = "spock"

        when:

        def testValue2 = OperatingSystem.current().windows ? 'some value$PATH' : 'some value\\\\$PATH'
        def testValue3 = 'some value%PATH%'
        file("build.gradle") << '''
            application.applicationDefaultJvmArgs = [
                '-DtestValue=value',
                '-DtestValue2=some value$PATH',
                '-DtestValue3=some value%PATH%',
            ]
        '''

            extensions.getByType(MyExtension::class).some("api.get")
            extensions.configure<MyExtension> { some("api.configure") }
            the<MyExtension>().some("kotlin.reified.get")
            the(MyExtension::class).some("kotlin.kclass.get")
            configure<MyExtension> { some("kotlin.configure") }
            my.some("accessor.get")
            my { some("accessor.configure") }
        """)

        when:
        def taskDescriptor = Mock(InternalTaskDescriptor)
        _ * taskDescriptor.getId() >> ":someTask"
        _ * taskDescriptor.getName() >> 'some task'
        _ * taskDescriptor.getDisplayName() >> 'some task in human readable form'
        _ * taskDescriptor.getTaskPath() >> ':some:path'
        _ * taskDescriptor.getParentId() >> null

        when:
        def commandLineExecution = factory.convert(["--some-option"])
        commandLineExecution.execute(executionListener)

        then:
        1 * actionFactory1.configureCommandLineParser(!null) >> {
            CommandLineParser parser -> parser.option("some-option")
        }
        1 * actionFactory2.configureCommandLineParser(!null)

            assertHasErrorOutput("ERROR")
        }

        withPrecompiledKotlinScript(
            "some.gradle.kts", """
            plugins {
                ${outputFrom("plugins block", logger = false)}
                id("applied-output")
                TODO("some plugins block failure")
            }
        """
        )
        buildAndFail(":compileKotlin").apply {

Vous pouvez déclarer tous les types  de Python, pas seulement `str`.

Comme par exemple :

* `int`
* `float`
* `bool`
* `bytes`

```Python hl_lines="1"
{!../../../docs_src/python_types/tutorial005.py!}
```

### Types génériques avec des paramètres de types

        def file2 = new File("b")

        expect:
        def collection1 = factory.fixed("some collection", file1, file2)
        collection1.files == [file1, file2] as Set
        collection1.buildDependencies.getDependencies(null).empty
        collection1.toString() == "some collection"

        def collection2 = factory.fixed("some collection", [file1, file2])
        collection2.files == [file1, file2] as Set