#*    *### add dependency info to output

- $directory/${project.artifact.artifactId}-${project.artifact.version}.jar: $project.artifact.toString().replace( ':eclipse-plugin:', ':jar:' )
    Project: $project.name
    #if ( $project.url )Project URL: ${project.url}#end

    License: $license.name#if ( $spdx ) ($spdx)#end

    License URL: $license.url ($licFile)

#*  *##end

                plan.steps(project).forEach(step -> {
                    if (step.predecessors.stream().noneMatch(s -> s.project == project)) {
                        step.executeAfter(setup);
                    } else if (step.successors.stream().noneMatch(s -> s.project == project)) {
                        teardown.executeAfter(step);
                    }
                });

        MavenProject project = new MavenProject(model);

        assertEquals("test-group", project.getGroupId(), "groupId proto-inheritance failed.");
        assertEquals("real-artifact", project.getArtifactId(), "artifactId is masked.");
        assertEquals("1000", project.getVersion(), "version proto-inheritance failed.");

        // draw the NPE.
        project.getId();
    }

    @Test

        String key = "${project.artifactId} with version: ${project.version}";

        MavenProject project = createDefaultProject();
        project.setArtifactId("test");
        project.setVersion("1");

        ExpressionEvaluator ee = createExpressionEvaluator(project, new Properties());

        Object value = ee.evaluate(key);

        lifecyclePluginResolver.resolveMissingPluginVersions(project, session);

        final List<MojoExecution> executions = calculateMojoExecutions(session, project, tasks);

        if (setup) {
            setupMojoExecutions(session, project, executions);
        }

        final List<ExecutionPlanItem> planItem = ExecutionPlanItem.createExecutionPlanItems(project, executions);

    /**
     * How the test project is set up:
     *
     * 1. dependencyManagement lists dependencies on a & b,
     *    with an exclusion on c in b.
     * 2. the child project lists a dependency on project a only
     * 3. a depends on b (which is transitive to the child project),
     *    and b depends on c.
     *

        Stream.of(p1, p2).forEach(project -> {
            plan.requiredStep(project, "after:resources").addMojo(new MojoExecution(null), 0);
            plan.requiredStep(project, "after:test-resources").addMojo(new MojoExecution(null), 0);
            plan.requiredStep(project, "compile").addMojo(new MojoExecution(null), 0);
            plan.requiredStep(project, "test-compile").addMojo(new MojoExecution(null), 0);

/**
 * Test sorting projects by dependencies.
 *
 */
class ProjectSorterTest {
    private Parent createParent(MavenProject project) {
        return createParent(project.getGroupId(), project.getArtifactId(), project.getVersion());
    }

    private Parent createParent(String groupId, String artifactId, String version) {
        Parent plugin = new Parent();
        plugin.setGroupId(groupId);

import org.apache.maven.project.CycleDetectedException;
import org.apache.maven.project.DuplicateProjectException;
import org.apache.maven.project.MavenProject;
import org.apache.maven.project.ProjectBuildingException;
import org.apache.maven.project.collector.MultiModuleCollectionStrategy;
import org.apache.maven.project.collector.PomlessCollectionStrategy;
import org.apache.maven.project.collector.RequestPomCollectionStrategy;

                }
            }
        } else {
            MavenProject project = createStubMavenProject();
            project.setRemoteArtifactRepositories(request.getRemoteRepositories());
            project.setPluginArtifactRepositories(request.getPluginArtifactRepositories());
            projects.add(project);
        }