super(message);
        this.project = project;
    }

    public LifecycleExecutionException(String message, MojoExecution execution, MavenProject project, Throwable cause) {
        super(message, cause);
        this.project = project;
    }

    public LifecycleExecutionException(MojoExecution execution, MavenProject project, Throwable cause) {

    /**
     * Create the MojoExecution configuration based on configuration for a Mojo in the MavenProject and the
     * default configuration for the Mojo from the containing plugin's plugin.xml descriptor.
     *
     * @param project
     * @param mojoExecution
     * @param allowPluginLevelConfig
     */
    void configure(MavenProject project, MojoExecution mojoExecution, boolean allowPluginLevelConfig);

    private final MavenProject project;

    public PhaseRecorder(MavenProject project) {
        this.project = project;
    }

    public void observeExecution(MojoExecution mojoExecution) {
        String lifecyclePhase = mojoExecution.getLifecyclePhase();

        if (lifecyclePhase != null) {
            PhaseId phaseId = PhaseId.of(lifecyclePhase);
            if (lastLifecyclePhase == null) {

    private final MavenProject project;

    private final List<MojoExecution> executionPlan;

    private final Throwable cause;

    public ProjectExecutionEvent(MavenSession session, MavenProject project) {
        this(session, project, null, null);
    }

    public ProjectExecutionEvent(MavenSession session, MavenProject project, List<MojoExecution> executionPlan) {
        this(session, project, executionPlan, null);
    }

@Singleton
public class DefaultMojosExecutionStrategy implements MojosExecutionStrategy {
    @Override
    public void execute(List<MojoExecution> mojos, MavenSession session, MojoExecutionRunner mojoRunner)
            throws LifecycleExecutionException {
        for (MojoExecution mojoExecution : mojos) {
            mojoRunner.run(mojoExecution);
        }
    }

        }
    }

    @Override
    public void releaseMojo(Object mojo, MojoExecution mojoExecution) {
        if (mojo != null) {
            try {
                container.release(mojo);
            } catch (ComponentLifecycleException e) {
                String goalExecId = mojoExecution.getGoal();

                if (mojoExecution.getExecutionId() != null) {
                    logger.debug(

        MojoDescriptor mojo = new MojoDescriptor();
        mojo.setPluginDescriptor(pluginDescriptor);
        mojo.setGoal("goal");

        MojoExecution mojoExecution = new MojoExecution(mojo);

        return new PluginParameterExpressionEvaluator(session, mojoExecution);
    }

    protected Artifact createArtifact(String groupId, String artifactId, String version) throws Exception {

public class DefaultMojoExecution implements MojoExecution {
    private final InternalMavenSession session;
    private final org.apache.maven.plugin.MojoExecution delegate;

    public DefaultMojoExecution(InternalMavenSession session, org.apache.maven.plugin.MojoExecution delegate) {
        this.session = session;
        this.delegate = delegate;
    }

    public org.apache.maven.plugin.MojoExecution getDelegate() {
        return delegate;

        node2.mojos.forEach((k, v) -> node1.mojos.merge(k, v, this::mergeMojos));
        return node1;
    }

    private Map<String, MojoExecution> mergeMojos(Map<String, MojoExecution> l1, Map<String, MojoExecution> l2) {
        l2.forEach(l1::putIfAbsent);
        return l1;
    }

import org.apache.maven.internal.transformation.TransformerManager;
import org.apache.maven.lifecycle.MavenExecutionPlan;
import org.apache.maven.lifecycle.internal.builder.BuilderCommon;
import org.apache.maven.plugin.MojoExecution;
import org.apache.maven.project.MavenProject;

/**
 * <p>
 * Builds one or more lifecycles for a full module
 * </p>