MavenExecutionPlan plan = LifecycleExecutionPlanCalculatorStub.getProjectAExecutionPlan();
        final List<MojoExecution> executions = plan.getMojoExecutions();

        final MojoExecution mojoExecution1 = executions.get(0);
        final MojoExecution mojoExecution2 = executions.get(1);
        phaseRecorder.observeExecution(mojoExecution1);

/**
 * Handles expansion of general build plugin configuration into individual executions.
 *
 * @deprecated use {@code org.apache.maven.api.services.ModelBuilder} instead
 */
@Deprecated(since = "4.0.0")
public interface PluginConfigurationExpander {

    /**
     * Merges values from general build plugin configuration into the individual plugin executions of the given model.
     *

     */
    ModelBuildingRequest setValidationLevel(int validationLevel);

    /**
     * Indicates whether plugin executions and configurations should be processed. If enabled, lifecycle-induced plugin
     * executions will be injected into the model and common plugin configuration will be propagated to individual
     * executions.
     *
     * @return {@code true} if plugins should be processed, {@code false} otherwise.
     */

    }

    public static List<ExecutionPlanItem> createExecutionPlanItems(
            MavenProject mavenProject, List<MojoExecution> executions) {
        BuilderCommon.attachToThread(mavenProject);

        List<ExecutionPlanItem> result = new ArrayList<>();
        for (MojoExecution mojoExecution : executions) {
            result.add(new ExecutionPlanItem(mojoExecution));
        }
        return result;
    }

            writer.accept("Build plan will be lazily computed");
        } else {
            plan.steps(project)
                    .filter(step ->
                            step.phase != null && step.executions().findAny().isPresent())
                    .sorted(Comparator.comparingInt(plan.sortedNodes()::indexOf))
                    .forEach(step -> {

 * specific language governing permissions and limitations
 * under the License.
 */

/**
 * Contains classes for managing plugin-specific lifecycle bindings and forked executions.
 * This package helps define how plugins can modify or extend Maven's build lifecycle.
 *
 * @since 4.0.0
 */

            count = count + 1;

            validPluginCounts.put(pluginArtifactId, count);
        }

        assertNotNull(testPlugin);

        List<PluginExecution> executions = testPlugin.getExecutions();

        assertEquals(1, executions.size());
    }

    private static Plugin newPlugin(String artifactId, String... goals) {
        return Plugin.newBuilder()
                .groupId("org.apache.maven.plugins")
                .artifactId(artifactId)
                .executions(Arrays.stream(goals)
                        .map(goal -> PluginExecution.newBuilder()
                                .id("default-" + goal)
                                .goals(List.of(goal))

    private static Plugin newPlugin(String artifactId, String... goals) {
        return Plugin.newBuilder()
                .groupId("org.apache.maven.plugins")
                .artifactId(artifactId)
                .executions(Arrays.stream(goals)
                        .map(goal -> PluginExecution.newBuilder()
                                .id("default-" + goal)
                                .goals(List.of(goal))

                                .version(pluginDescriptor.getVersion())
                                .configuration(phase.getConfiguration())
                                .executions(phase.getExecutions().stream()
                                        .map(exec -> org.apache.maven.api.model.PluginExecution.newBuilder()
                                                .goals(exec.getGoals())