assertNotNull(event.getProject());
                assertNotNull(event.getExecution());
                assertNotNull(event.getMojo());
                assertNull(event.getCause());

                log.add("beforeMojoExecution " + event.getProject().getArtifactId() + ":"
                        + event.getExecution().getExecutionId());
            }

            @Override

        this.cause = cause;
    }

    public MavenSession getSession() {
        return session;
    }

    public MavenProject getProject() {
        return project;
    }

    public MojoExecution getExecution() {
        return mojoExecution;
    }

    public Mojo getMojo() {
        return mojo;
    }

    public Throwable getCause() {
        return cause;
    }

        getExecutions().add(execution);
    } // -- void addExecution( Execution )

    /**
     * Get configuration to pass to all goals run in this phase.
     *
     * @return Object
     */
    public Object getConfiguration() {
        return this.configuration;
    } // -- Object getConfiguration()

    /**
     * Method getExecutions.
     *
     * @return List
     */

                Plugin target, Plugin source, boolean sourceDominant, Map<Object, Object> context) {
            List<PluginExecution> src = source.getExecutions();
            if (!src.isEmpty()) {
                List<PluginExecution> tgt = target.getExecutions();
                Map<Object, PluginExecution> merged = new LinkedHashMap<>((src.size() + tgt.size()) * 2);

                for (PluginExecution element : tgt) {

                if (existing != null) {
                    if (version == null) {
                        version = existing.getVersion();
                    }
                    execs.addAll(existing.getExecutions());
                    deps.addAll(existing.getDependencies());
                }

                PluginExecution execution = PluginExecution.newBuilder()
                        .id(getExecutionId(existing, goal))

                }

                if (mojo.getDependencies() != null) {
                    plugin.setDependencies(mojo.getDependencies());
                }
                plugin.getExecutions().add(execution);
            }
        }
    }

    private GoalSpec parseGoalSpec(String goalSpec) {
        GoalSpec gs = new GoalSpec();

        String[] p = goalSpec.trim().split(":");

        // Goal specific configuration
        // ----------------------------------------------------------------------

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

        PluginExecution execution = executions.get(0);

        String g0 = execution.getGoals().get(0);

        assertEquals("plexus:runtime", g0);

                Plugin target, Plugin source, boolean sourceDominant, Map<Object, Object> context) {
            List<PluginExecution> src = source.getExecutions();
            if (!src.isEmpty()) {
                List<PluginExecution> tgt = target.getExecutions();

                Map<Object, PluginExecution> merged = new LinkedHashMap<>((src.size() + tgt.size()) * 2);

                for (PluginExecution element : src) {

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

        Map<String, List<String>> goals = new HashMap<>();
        lifecycle.allPhases().forEach(phase -> phase.plugins()
                .forEach(plugin -> plugin.getExecutions().forEach(exec -> exec.getGoals()
                        .forEach(goal -> goals.computeIfAbsent(phase.name(), n -> new ArrayList<>())