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")

    }

    def "renders only tasks in given group running [tasks, --group=build setup]"() {
        settingsFile << "rootProject.name = 'test'"
        buildFile << """
            task mytask {
                group = "custom"
            }
        """
        when:
        succeeds "tasks", "--group=build setup"

        then:
        output.contains("""

        setup:
        def latch = new AtomicBoolean()

        when:
        def project = buildProject()

        project.getTasksByName('myTask', true)

        project.afterEvaluate {
            latch.getAndSet(true)
        }

        project.evaluate()

        then:
        noExceptionThrown()
        latch.get()
    }

                }
            }

            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 {

            import org.gradle.api.*

            class ${className} implements Plugin<Project> {
                void apply(Project project) {
                    project.tasks.create("myTask${className}") {
                        doLast {
                            def closure = {
                                println "From ${className}"
                            }
                            closure()

General::
 * `<<` for task definitions no longer works. In other words, you can not use the syntax `task myTask << { ... }`.
+
Use the link:{groovyDslPath}/org.gradle.api.Task.html#org.gradle.api.Task:doLast(org.gradle.api.Action)[Task.doLast()] method instead, like this:
+
----
task myTask {
    doLast {
        ...
    }
}
----

        given:
        buildFile << """
            class Param<T> {
                T display
                String toString() { display.toString() }
            }

            abstract class MyTask extends DefaultTask {
                @Input
                abstract MapProperty<$keyType, $valueType> getProp()

                @TaskAction
                void go() {

| Returns `void`, so it cannot be chained.

|===

== Eager APIs to avoid

[cols="a,a", options="header"]
|===
| API
| Note

| `task myTask(type: MyTask) {}`
| Do not use the shorthand notation. Use `register()` instead.

| link:{javadocPath}/org/gradle/api/tasks/TaskContainer.html#create-java.util.Map-[TaskContainer.create()]
| Use `register()` instead.