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

		{
			name:        "wrong param",
			template:    "{{ .Other.some.thing }}",
			expectFound: false,
		},
		{
			name:        "basic",
			template:    "{{ .To }}",
			expectFound: true,
		},
		{
			name:        "with method calls",
			template:    "{{ .To.some.thing }}",
			expectFound: true,
		},
		{
			name:        "if",
			template:    "{{ if .To.some.thing }}{{ end }}",
			expectFound: true,
		},
		{

        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)

        def some = withFile("some.gradle.kts", getBuildScriptDependency(someJar))
        def settings = withSettings("""${getBuildScriptDependency(settingsJar)}
            apply(from = "some.gradle.kts")
            include("a", "b")
        """)
        def root = withBuildScript("""
            ${getBuildScriptDependency(rootJar)}
            apply(from = "some.gradle.kts")
        """)

            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

    with pytest.raises(WebSocketDisconnect):
        with client.websocket_connect("/items/bar/ws?token=some-token") as websocket:
            message = "Message one"
            websocket.send_text(message)
            data = websocket.receive_text()
            assert data == "Session cookie or query token value is: some-token"
            data = websocket.receive_text()

        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

    with pytest.raises(WebSocketDisconnect):
        with client.websocket_connect("/items/bar/ws?token=some-token") as websocket:
            message = "Message one"
            websocket.send_text(message)
            data = websocket.receive_text()
            assert data == "Session cookie or query token value is: some-token"
            data = websocket.receive_text()

        availability.unavailable("some reason")

        when:
        availability.explain(visitor)

        then:
        1 * visitor.node("some reason")
    }

    def "visits message when unsupported"() {
        def visitor = Mock(DiagnosticsVisitor)

        given:
        def availability = new ToolChainAvailability()
        availability.unsupported("some reason")

        when: