}

    @Override
    public String getExecutionId() {
        return delegate.getExecutionId();
    }

    @Override
    public String getGoal() {
        return delegate.getGoal();
    }

    @Override
    public Optional<XmlNode> getConfiguration() {
        return Optional.of(delegate.getConfiguration()).map(Xpp3Dom::getDom);
    }

    @Override

        assertEquals(2, pd.getMojos().size());
        assertEquals(1, pd.getDependencies().size());

        MojoDescriptor md = pd.getMojos().get(0);

        assertEquals("jar", md.getGoal());
        assertEquals("mojo-description", md.getDescription());
        assertEquals("runtime", md.getDependencyResolutionRequired());
        assertEquals("test", md.getDependencyCollectionRequired());

                LifecycleMojo mojo = mojos.get(i);

                GoalSpec gs = parseGoalSpec(mojo.getGoal());

                if (gs == null) {
                    logger.warn(
                            "Ignored invalid goal specification '{}' from lifecycle mapping for phase {}",
                            mojo.getGoal(),
                            phase);
                    continue;
                }

 *
 * @see LifecyclePhase
 */
public class LifecycleMojo {

    private String goal;
    private XmlNode configuration;
    private List<Dependency> dependencies;

    public String getGoal() {
        return goal;
    }

    public XmlNode getConfiguration() {
        return configuration;
    }

    public List<Dependency> getDependencies() {
        return dependencies;
    }

    Plugin getPlugin();

    @Nonnull
    PluginExecution getModel();

    @Nonnull
    MojoDescriptor getDescriptor();

    @Nonnull
    String getExecutionId();

    @Nonnull
    String getGoal();

    @Nonnull
    String getLifecyclePhase();

    @Nonnull
    Optional<XmlNode> getConfiguration();

        return lifecycleMojo;
    };

    @Override
    public String toString() {
        return Optional.ofNullable(getMojos()).orElse(Collections.emptyList()).stream()
                .map(LifecycleMojo::getGoal)
                .collect(Collectors.joining(","));
    }

    @Deprecated
    public static Map<String, String> toLegacyMap(Map<String, LifecyclePhase> lifecyclePhases) {
        if (lifecyclePhases == null) {

            init();
            logger.warn(
                    "Goal '{}' requires online mode for execution but Maven is currently offline, skipping",
                    event.getMojoExecution().getGoal());
        }
    }

    /**
     * <pre>--- mojo-artifactId:version:goal (mojo-executionId) @ project-artifactId ---</pre>
     */
    @Override
    public void mojoStarted(ExecutionEvent event) {

                    + ':'
                    + execution.getArtifactId()
                    + ':'
                    + execution.getVersion()
                    + ':'
                    + execution.getGoal());
            buffer.a(' ').strong('(' + execution.getExecutionId() + ')');
        }

        if (project != null) {
            buffer.a(" on project ");
            buffer.project(project.getArtifactId());

        String mojoExecId =
                mojoExecution.getGroupId() + ':' + mojoExecution.getArtifactId() + ':' + mojoExecution.getVersion()
                        + ':' + mojoExecution.getGoal() + " (" + mojoExecution.getExecutionId() + ')';

        Map<String, List<MojoExecution>> forkedExecutions = mojoExecution.getForkedExecutions();
        if (!forkedExecutions.isEmpty()) {

        if (mojoDescriptor == null) {
            mojoDescriptor = pluginManager.getMojoDescriptor(
                    execution.getPlugin(),
                    execution.getGoal(),
                    project.getRemotePluginRepositories(),
                    session.getRepositorySession());

            execution.setMojoDescriptor(mojoDescriptor);
        }