for (TaskSegment taskSegment : taskSegments) {
            mergedSegment.getTasks().addAll(taskSegment.getTasks());
        }

        return lifecycleExecutionPlanCalculator.calculateExecutionPlan(
                session, session.getCurrentProject(), mergedSegment.getTasks(), setup);
    }

    public MavenExecutionPlan calculateExecutionPlan(MavenSession session, String... tasks)

        this.aggregating = aggregating;
        this.tasks = new ArrayList<>(Arrays.asList(tasks));
    }

    @Override
    public String toString() {
        return getTasks().toString();
    }

    public List<Task> getTasks() {
        return tasks;
    }

    public boolean isAggregating() {
        return aggregating;
    }

    // TODO Consider throwing UnsupportedSomething on hashCode/equals

                }

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

    assertTrue("No events should be delivered synchronously.", events.isEmpty());

    // Now we find the task in our Executor and explicitly activate it.
    List<Runnable> tasks = executor.getTasks();
    assertEquals("One event dispatch task should be queued.", 1, tasks.size());

    tasks.get(0).run();

    assertEquals("One event should be delivered.", 1, events.size());

    }

    private static void updateDocumentationExtension(Project project, GradleDocumentationExtension extension) {
        TaskProvider<Task> generateTask = project.getTasks().named(TASK_NAME);
        Provider<? extends Directory> outputDirectory = generateTask.flatMap(t -> ((DokkatooGenerateTask) t).getOutputDirectory());

    assertTrue("No events should be delivered synchronously.", events.isEmpty());

    // Now we find the task in our Executor and explicitly activate it.
    List<Runnable> tasks = executor.getTasks();
    assertEquals("One event dispatch task should be queued.", 1, tasks.size());

    tasks.get(0).run();

    assertEquals("One event should be delivered.", 1, events.size());

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

        MavenExecutionPlan executionPlan = lifecycleExecutionPlanCalculator.calculateExecutionPlan(
                session1, ProjectDependencyGraphStub.A, taskSegment1.getTasks());
        assertEquals(2, executionPlan.size());

        final GoalTask goalTask3 = new GoalTask("surefire:test");
        final TaskSegment taskSegment2 = new TaskSegment(false, goalTask1, goalTask2, goalTask3);

    }

    private static TaskSegment createTaskSegment() {
        TaskSegment result = new TaskSegment(false);
        result.getTasks().add(new GoalTask("t1"));
        result.getTasks().add(new GoalTask("t2"));
        return result;
    }

    class Dependency {
        MavenProject dependant;

        MavenProject dependency;

 */
public class GradleReleaseNotesPlugin implements Plugin<Project> {
    @Override
    public void apply(Project project) {
        ProjectLayout layout = project.getLayout();
        TaskContainer tasks = project.getTasks();

        GradleDocumentationExtension extension = project.getExtensions().getByType(GradleDocumentationExtension.class);

        generateReleaseNotes(project, layout, tasks, extension);
    }