@Override
    public void apply(final Project project) {
        project.getPluginManager().apply(ReportingBasePlugin.class);

        final TaskProvider<GenerateBuildDashboard> buildDashboard = project.getTasks().register(BUILD_DASHBOARD_TASK_NAME, GenerateBuildDashboard.class, new Action<GenerateBuildDashboard>() {
            @Override
            public void execute(final GenerateBuildDashboard buildDashboardTask) {

        factory.allTasks.put(project, [task] as Set)
        def tasks = factory.getTasks(project)

        then:
        tasks.empty
    }

    def "returns tasks"() {
        TasksFactory factory = new TasksFactory(true)

        when:
        factory.allTasks = [:]
        factory.allTasks.put(project, [task] as Set)
        def tasks = factory.getTasks(project)

        then:
        tasks.size() == 1
    }

        this.taskPath = taskPath;
        this.tasks = Collections.emptyList();
        this.failure = failure;
    }

    public List<TaskDetails> getTasks() {
        if (failure != null) {
            // rethrow the original failure
            throw failure;
        }
        return tasks;
    }

    public String getTaskPath() {
        return taskPath;

            tasks.put(taskPath, result);
        }
        return result;
    }

    /**
     * Returns the task executions for this project.
     */
    public CompositeOperation<TaskExecution> getTasks() {
        List<TaskExecution> taskExecutions = CollectionUtils.sort(tasks.values(), slowestFirst());
        return new CompositeOperation<TaskExecution>(taskExecutions);
    }

    /**

                }

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

            import ${Project.name};
            import ${Plugin.name};

            public class PluginImpl implements Plugin<Project> {
                public void apply(Project project) {
                    project.getTasks().register("greeting", task -> {
                        task.doLast(s -> System.out.println("Hello world"));
                    });
                }
            }
        """
    }

    /**

        final String signTaskName = determineSignTaskNameForPublication(publicationToSign);
        if (project.getTasks().getNames().contains(signTaskName)) {
            return project.getTasks().named(signTaskName, Sign.class).get();
        }
        final Sign signTask = project.getTasks().create(signTaskName, Sign.class, task -> {

    }

    def "dependsOn() works"() {
        given:
        def dependsOnTask = createTask(project, "somename")
        def task = createTask(project, TEST_TASK_NAME)
        project.getTasks().create("path1")
        project.getTasks().create("path2")

        when:
        task.dependsOn(Project.PATH_SEPARATOR + "path1")

        then:
        task dependsOn("path1")

        when:

    }

    @Override
    protected void renderTasks(NativeTestSuiteBinarySpec binary, TextReportBuilder builder) {
        builder.item("install using task", binary.getTasks().getInstall().getPath());
        builder.item("run using task", binary.getTasks().getRun().getPath());
    }

    @Override
    protected void renderOutputs(NativeTestSuiteBinarySpec binary, TextReportBuilder builder) {

package org.example;

import org.gradle.api.Project;
import org.gradle.api.Plugin;

public class GreetingPlugin implements Plugin<Project> {

    @Override
    public void apply(Project target) {
        target.getTasks().register("hello", GreetingTask.class);
    }