if (type == null) {
            return Optional.empty();
        }
        return Optional.of(new DefaultPackaging(id, type, getPlugins(lifecycleMapping)));
    }

    private Map<String, PluginContainer> getPlugins(LifecycleMapping lifecycleMapping) {
        Map<String, PluginContainer> lfs = new HashMap<>();
        lifecycleMapping.getLifecycles().forEach((id, lifecycle) -> {

        assertEquals("activated", result.getEffectiveModel().getProperties().get("profile.file"));
        Xpp3Dom conf = (Xpp3Dom)
                result.getEffectiveModel().getBuild().getPlugins().get(0).getConfiguration();
        assertNotNull(conf);
        assertEquals("1.5", conf.getChild("source").getValue());
        assertEquals("  1.5  ", conf.getChild("target").getValue());
    }

    @Test

                + "      </plugin>\n"
                + "    </plugins>\n"
                + "  </build>\n"
                + "</project>";

        Model model = fromXml(xml);
        Plugin plugin = model.getBuild().getPlugins().get(0);
        XmlNode node = plugin.getConfiguration();
        assertNotNull(node);
        assertEquals("http://maven.apache.org/POM/4.0.0", node.namespaceUri());
        assertEquals("m", node.prefix());

        addPluginMapping(goalPrefix, artifactId, artifactId);
    }

    public void addPluginMapping(String goalPrefix, String artifactId, String name) {
        List<Plugin> plugins = getMetadata().getPlugins();
        boolean found = false;
        for (Iterator<Plugin> i = plugins.iterator(); i.hasNext() && !found; ) {
            Plugin plugin = i.next();
            if (plugin.getPrefix().equals(goalPrefix)) {

         * not interested in any of the executions bound to it.
         */

        for (Plugin plugin : project.getBuild().getPlugins()) {
            for (PluginExecution execution : plugin.getExecutions()) {
                // if the phase is specified then I don't have to go fetch the plugin yet and pull it down

        Plugin pluginInPom = findPlugin(plugin, project.getBuildPlugins());

        if (pluginInPom == null && project.getPluginManagement() != null) {
            pluginInPom = findPlugin(plugin, project.getPluginManagement().getPlugins());
        }

        if (pluginInPom != null) {
            if (plugin.getVersion() == null) {
                plugin.setVersion(pluginInPom.getVersion());
            }

                        .collect(Collectors.toSet());
                for (BuildStep step : planSteps) {
                    MavenProject project = step.project;
                    for (Plugin plugin : project.getBuild().getPlugins()) {
                        for (PluginExecution execution : plugin.getExecutions()) {
                            for (String goal : execution.getGoals()) {

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

                for (Plugin element : tgt) {

        plugin.setArtifactId(pluginInfo.artifactId);
        plugin.setName(pluginInfo.name);
        result.getPlugins().add(plugin);
        return result;
    }

    @Override
    protected void merge(Metadata recessive) {
        List<Plugin> recessivePlugins = recessive.getPlugins();
        List<Plugin> plugins = metadata.getPlugins();
        if (!recessivePlugins.isEmpty() || !plugins.isEmpty()) {

        Build build = model.getBuild();

        if (build != null) {
            expand(build.getPlugins());

            PluginManagement pluginManagement = build.getPluginManagement();

            if (pluginManagement != null) {
                expand(pluginManagement.getPlugins());
            }
        }
    }

    private void expand(List<Plugin> plugins) {