Some plugins also add their own command line options.

[[command_line_executing_tasks]]
=== Executing tasks
To execute a task called `taskName` on the root project, type:

----
$ gradle :taskName
----

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

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

import gradlebuild.buildutils.tasks.GenerateSubprojectsInfo
import gradlebuild.buildutils.tasks.CheckSubprojectsInfo

tasks.register<GenerateSubprojectsInfo>(GenerateSubprojectsInfo.TASK_NAME)

// tag::all[]
// tag::task-rule[]
tasks.addRule("Pattern: ping<ID>") {
    val taskName = this
    if (startsWith("ping")) {
        task(taskName) {
            doLast {
                println("Pinging: " + (taskName.replace("ping", "")))
            }
        }
    }
}
// end::task-rule[]

tasks.register("groupPing") {
    dependsOn("pingServer1", "pingServer2")
}

                }
            }

            task ${taskName}(type: InputDirectoryContentToOutputFileAction) {
                inputDirectory = new File("${drive}\\\\")
                output = file("${TextUtil.escapeString(outputFile.absolutePath)}")
            }
        """
        when:
        buildScript script

        then:
        succeeds taskName
        outputFile.text.contains inputFileName

        cleanup:

        return this;
    }

    @Override
    public List<String> getArgs() {
        return Collections.singletonList(taskName);
    }

    public LaunchableGradleTaskSelector setTaskName(String taskName) {
        this.taskName = taskName;
        return this;
    }

    @Override
    public String getProjectPath() {
        return projectIdentifier.getProjectPath();
    }

            import java.util.concurrent.TimeUnit

            tasks.addRule("") { taskName ->
                if (taskName.startsWith("verifyMaxWorkers")) {
                    task(taskName) { task ->
                        doLast {
                            def count = (taskName - "verifyMaxWorkers") as int
                            def latch = new CountDownLatch(count)

        binary.inputs.withType(MarkdownSourceSet) { markdownSourceSet ->
            def taskName = binary.tasks.taskName("compile", markdownSourceSet.name)
            def outputDir = new File(binary.outputDir, markdownSourceSet.name)
            tasks.create(taskName, MarkdownHtmlCompile) { compileTask ->
                compileTask.source = markdownSourceSet.source

    def "returned service ref refers to service for that build"() {
        given:
        def taskName = "printInvocationId"
        buildFile << taskPrintBuildInvocationId(taskName)

        when:
        succeeds taskName, "--configuration-cache"
        def firstInvocationId = output.find(~/(?<=extension-buildInvocationId=).+(?=\n)/)
        succeeds taskName, "--configuration-cache"

class TasksFromProjectDependencies implements TaskDependencyContainerInternal {
    private final TaskDependencyContainerInternal taskDependencyDelegate;

    public TasksFromProjectDependencies(
        String taskName,
        Supplier<Set<ProjectDependency>> projectDependencies,
        TaskDependencyFactory taskDependencyFactory,
        ProjectStateRegistry projectStateRegistry
    ) {

        String taskRegistration(String taskName, String taskType);

        String taskConfiguration(String taskName, String taskType);

        String suiteRegistration(String taskName, String taskType);

        String suiteConfiguration(String taskName, String taskType);

        String referenceTask(String taskName);

        String referenceSuite(String taskName);