if (includeSubProjects) {
            Set<String> taskNames = new LinkedHashSet<>();
            collectTaskNames(project, taskNames);
            for (String taskName : taskNames) {
                selected.put(taskName, new MultiProjectTaskSelectionResult(taskName, project, true));
            }
        } else {
            discoverTasks(project);
            for (String taskName : getTaskNames(project)) {

            'file14.txt')

        where:
        taskName << ['zip', 'tar']
        taskType = taskName.capitalize()
        fileExtension = taskName
    }

    def "#taskName uses only first duplicate"() {
        given:
        duplicateEntriesInArchive(taskName, taskType, fileExtension)

        buildFile << """
            ${taskName} {
                duplicatesStrategy = DuplicatesStrategy.EXCLUDE

Executing Gradle on the command line conforms to the following structure:

----
gradle [taskName...] [--option-name...]
----

Options are allowed _before_ and _after_ task names.

----
gradle [--option-name...] [taskName...]
----

If multiple tasks are specified, you should separate them with a space.

----
gradle [taskName1 taskName2...] [--option-name...]
----

        private final String taskName;

        public TaskPathSpec(ProjectInternal targetProject, String taskName) {
            this.targetProject = targetProject;
            this.taskName = taskName;
        }

        @Override
        public boolean isSatisfiedBy(Task element) {
            if (!element.getName().equals(taskName)) {
                return true;
            }

        when:
        succeeds taskName
        def originalResults = extractResults()
        then:
        executedAndNotSkipped taskName

        when:
        succeeds taskName
        then:
        skipped taskName

        when:
        moveFilesAround()
        succeeds taskName
        then:
        skipped(taskName)

        when:
        removeResults()

    def "file and directory permissions are preserved when using #taskName task"() {
        given:
        createDir('parent') {
            child {
                mode = 0777
                file('reference.txt').mode = 0746
            }
        }
        def archName = "test.${taskName.toLowerCase()}"
        and:
        buildFile << """
            task pack(type: $taskName) {
                archiveFileName = "$archName"

public class ResolvedTaskPath {
    private final String prefix;
    private final String taskName;
    private final ProjectInternal project;
    private final boolean isQualified;

    public ResolvedTaskPath(String prefix, String taskName, ProjectInternal project) {
        this.prefix = prefix;
        this.taskName = taskName;
        this.project = project;
        this.isQualified = prefix.length() > 0;
    }

    }

    def "debug is disabled by default with task :#taskName"() {
        setup:
        sampleProject """
            debugOptions {
            }
        """

        expect:
        succeeds(taskName)

        where:
        taskName << ['runJavaExec', 'runExecOperationsJavaExec', 'test']
    }

    def "debug session fails without debugger with task :#taskName"() {
        setup:
        sampleProject """

        """
    }

    def "fails when applied in build with #taskName"() {
        buildFile << """

        task $taskName {
            doLast {
                println "custom $taskName task"
            }
        }
        """

        when:
        fails(taskName)

        then:
        failure.assertHasCause("Cannot add task '$taskName' as a task with that name already exists.")
        where:

    private final String taskName;
    private final String configurationName;
    private final TaskDependencyContainerInternal taskDependencyDelegate;

    public TasksFromDependentProjects(String taskName, String configurationName, TaskDependencyFactory taskDependencyFactory) {
        this(taskName, configurationName, new TaskDependencyChecker(), taskDependencyFactory);
    }