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();

    @Override protected String getLifecycleTaskName() {
        return 'testIde'
    }

    @Override protected void onApply(Project target) {
        def worker = target.task('generateXml')
        addWorker(target.getTasks().named(worker.getName()), worker.getName());
    }

                currentSegment.getTasks().add(new GoalTask(task));
            } else {
                // lifecycle phase

                if (currentSegment == null || currentSegment.isAggregating()) {
                    currentSegment = new TaskSegment(false);
                    taskSegments.add(currentSegment);
                }

                currentSegment.getTasks().add(new LifecycleTask(task));
            }

                    project.getTasks().withType(SomeTask.class).configureEach(task -> {
                        task.getConventionMapping().map("inputProperty", ext::getInputProperty);
                    });
                    project.getTasks().register("ok", SomeTask.class, task -> {
                    });
                }

    public TasksFactory(boolean includeTasks) {
        this.includeTasks = includeTasks;
    }

    public void collectTasks(Project root) {
        allTasks = root.getAllTasks(true);
    }

    public Set<Task> getTasks(Project project) {
        if (includeTasks) {
            return allTasks.get(project);
        } else {
            return emptySet();
        }
    }

    @Override
    public Collection<Task> listProjectTasks(Project project) {
        ProjectInternal projectInternal = (ProjectInternal) project;
        TaskContainerInternal tasks = projectInternal.getTasks();
        tasks.realize();
        return tasks;
    }

            });
        });

        project.getPlugins().withType(BasePlugin.class, plugin -> {
            project.getTasks().named(BasePlugin.ASSEMBLE_TASK_NAME).configure(assemble -> {
                assemble.dependsOn(exported.getArtifacts());
            });
        });

            CustomModel model = connection.getModel(CustomModel.class);
            System.out.println("Project: " + model.getName());
            System.out.println("Tasks: ");
            for (String task : model.getTasks()) {
                System.out.println("   " + task);
            }
        } finally {
            // Clean up
            connection.close();
        }
    }

package org.gradle.integtests.fixtures.executer;

import java.util.List;
import java.util.Set;

public interface TaskOrderSpec {
    int assertMatches(int lastIndex, List<String> executedTaskPaths);

    Set<String> getTasks();

                    "tasks",
                    Task.class,
                    binary.getTasks(),
                    taskFactory,
                    Named.Namer.INSTANCE,
                    new Action<Task>() {
                        @Override
                        public void execute(Task task) {
                            binary.getTasks().add(task);
                            binary.builtBy(task);
                        }