buildFile.text = """
            task myTask {
                doLast {
                    println "myTask"
                }
            }
        """.stripIndent()


        when:
        def connector = toolingApi.connector()
        withConnection(connector) { connection ->
            def build = connection.newBuild()
            build.forTasks('myTask').run()
        }

            tasks.register("myTask", MyTask.class) {
                classes.from(
                    files(${methodName}(myFc, project.layout.buildDirectory.get()))
                )
            }
        """

        when:
        run "myTask"

        then:
        outputContains("CONSUMING build/producerOutput")

        when:
        run "myTask"

        then:

interface Transformer {}

class Impl implements Transformer {}

class MyTask extends DefaultTask {
    public void transform(Class<? extends Transformer> c) {
        logger.lifecycle("transform(Class)")
    }

    public void transform(Transformer t) {
        logger.lifecycle("transform(Transformer)")
    }
}

task print(type: MyTask) {
    transform(Impl) // should call transform(Class)
}
        """

 * org.gradle.api.tasks.TaskContainer#create(String)} creates an empty task with the given name. You can also use the
 * {@code task} keyword in your build file: </p>
 * <pre>
 * task myTask
 * task myTask { configure closure }
 * task myTask(type: SomeType)
 * task myTask(type: SomeType) { configure closure }
 * </pre>
 *
 * <p>Each task has a name, which can be used to refer to the task within its owning project, and a fully qualified

            }.get().executablePath)

            task myTask {
                doLast {
                    println "Hello from \${name}"
                }
            }
        """

        when:
        withInstallations(jdkMetadata).run(":myTask")
        def events = toolchainEvents(":myTask")

        then:
        events.size() == 0

To execute a task called `myTask` on the root project, type:

----
$ gradle :myTask
----

This will run the single `myTask` and all of its <<tutorial_using_tasks.adoc#sec:task_dependencies,dependencies>>.

[[sec:disambiguate_task_options_from_built_in_options]]
=== Specify options for tasks

        file('other-build/settings.gradle') << "rootProject.name = 'other-build'"
        file('other-build/build.gradle') << """
            tasks.register('doSomething', MyTask)

            class MyTask extends DefaultTask {
                private String content = 'default content'

                @Option(option = "content", description = "Message to print")

                }
            }

            abstract class MyTask extends DefaultTask {
                @Input
                abstract Property<String> getGreeting()

                @TaskAction void run() { println greeting.get() }
            }

            def greetValueSource = providers.of(GreetValueSource) {}
            tasks.register("greet", MyTask) {
                greeting = greetValueSource
            }

            }
        """
        file('build-logic/src/main/groovy/MyTask.groovy') << """
            import org.gradle.api.*
            import org.gradle.api.file.*
            import org.gradle.api.tasks.*
            import org.gradle.workers.*
            import javax.inject.Inject

            abstract class MyTask extends DefaultTask {

    }

    def "buildSrc is loaded from cache"() {
        configureCacheForBuildSrc()
        file("buildSrc/src/main/groovy/MyTask.groovy") << """
            import org.gradle.api.*

            class MyTask extends DefaultTask {}
        """

        when:
        withBuildCache().run "help"
        then:
        result.assertTaskNotSkipped(":buildSrc:compileGroovy")