_ * defaultProject.defaultTasks >> ['a', 'b']

        when:
        action.scheduleRequestedTasks(gradle, selector, plan)

        then:
        1 * startParameter.setTaskNames(['a', 'b'])
        1 * delegate.scheduleRequestedTasks(gradle, selector, plan)
    }

    def "uses default build-in tasks if no tasks specified in StartParameter or project"() {
        given:

            project.task(placeHolderTaskName);
            taskPaths.add(placeHolderTaskName);
        }

        project.getGradle().getStartParameter().setTaskNames(taskPaths);
        return null;
    }

    private static boolean isSyncModel(String modelName) {
        return modelName.equals("org.gradle.tooling.model.eclipse.RunEclipseSynchronizationTasks");
    }

        projectPropertiesCommandLineConverter.convert(parsedCommandLine, startParameter.getProjectProperties());

        if (!parsedCommandLine.getExtraArguments().isEmpty()) {
            startParameter.setTaskNames(parsedCommandLine.getExtraArguments());
        }

        buildOptionsConverter.convert(parsedCommandLine, properties.getProperties(), startParameter);

        return startParameter;
    }

            } else {
                LOGGER.info("No tasks specified. Using project default tasks {}", GUtil.toString(defaultTasks));
            }

            startParameter.setTaskNames(defaultTasks);
        }

        delegate.scheduleRequestedTasks(gradle, selector, plan);
    }

            Task task = rootProject.task(parentTaskName);
            task.dependsOn(buildDependencies.toArray(new Object[0]));
            taskPaths.add(parentTaskName);
            startParameter.setTaskNames(taskPaths);
        }
        return DefaultRunClosedProjectBuildDependencies.INSTANCE;
    }

    private Gradle getRootGradle(Gradle gradle) {
        Gradle parent = gradle.getParent();

        if (launchables != null) {
            startParameter.setTaskRequests(unpack(launchables));
        } else if (parameters.getTasks() != null) {
            startParameter.setTaskNames(parameters.getTasks());
        }

        List<String> arguments = parameters.getArguments();
        StartParameterConverter converter = new StartParameterConverter();

    }

    def "contains build description"() {
        given:
        def param = new StartParameter()
        param.setTaskNames(["foo", "bar"])
        param.setExcludedTaskNames(["one", "two"])

        when:
        profile = new BuildProfile(param, new BuildStartedTime(0))

        then:

     *
     * @param tasks The task names. May be empty or null to use the default tasks for the build.
     */
    public void setTasks(Collection<String> tasks) {
        getStartParameter().setTaskNames(tasks);
    }

    /**
     * The build name to use for the nested build.
     * <p>
     * If no value is specified, the name of the directory of the build will be used.
     *

        // Restore startParameter.taskNames to enable `gradle.startParameter.setTaskNames(...)` idiom in included build scripts
        // See org/gradle/caching/configuration/internal/BuildCacheCompositeConfigurationIntegrationTest.groovy:134
        val startParameterTaskNames = readStrings()
        gradle.startParameter.setTaskNames(startParameterTaskNames)
    }

    private

                        Set<String> tasks = new HashSet(startParameter.getTaskNames());
                        tasks.addAll(parameter.getTasks());
                        startParameter.setTaskNames(tasks);
                        return new DefaultCustomModel('loadingWithTasks');
                    }
                    return null
                }
            }
        """
    }