PluginExecution existing = merged.get(key);
                    if (existing != null) {
                        mergePluginExecution(existing, element, sourceDominant, context);
                    } else {
                        merged.put(key, element.clone());
                    }
                }

                target.setExecutions(new ArrayList<>(merged.values()));
            }
        }

            merger.merge(model, lifecycleModel);
        }
    }

    /**
     *  The domain-specific model merger for lifecycle bindings
     */
    protected static class LifecycleBindingsMerger extends MavenModelMerger {

        private static final String PLUGIN_MANAGEMENT = "plugin-management";

        public void merge(Model target, Model source) {

                    );

            UpgradeResult merged = result1.merge(result2);

            assertTrue(merged.success(), "Merged result should be successful");
            assertEquals(2, merged.processedPoms().size(), "Should merge processed POMs");
            assertEquals(2, merged.modifiedPoms().size(), "Should merge modified POMs");
            assertTrue(merged.processedPoms().contains(pom1), "Should contain overlapping POM");

            Properties merged = new Properties();
            if (sourceDominant) {
                merged.putAll(target.getProperties());
                putAll(merged, source.getProperties(), CHILD_DIRECTORY_PROPERTY);
            } else {
                putAll(merged, source.getProperties(), CHILD_DIRECTORY_PROPERTY);
                merged.putAll(target.getProperties());
            }

        Model source = Model.newBuilder().artifactId("SOURCE").build();

        Model merged = mavenMerger.merge(target, source, true, null);
        assertEquals(
                "SOURCE",
                merged.getArtifactId(),
                "Expected merged artifactId to be SOURCE but was " + merged.getArtifactId());

        merged = mavenMerger.merge(target, source, false, null);
        assertEquals(
                "TARGET",

                merged.put(key, element);
            }

            for (Repository element : recessive) {
                Object key = getRepositoryKey(element);
                if (!merged.containsKey(key)) {
                    merged.put(key, element);
                }
            }

            target.setRepositories(new ArrayList<>(merged.values()));
        }
    }

                    PluginExecution existing = merged.get(key);
                    if (existing != null) {
                        mergePluginExecution(element, existing, sourceDominant, context);
                    }
                    merged.put(key, element);
                }

                target.setExecutions(new ArrayList<>(merged.values()));
            }
        }
    }

            metadata.storeInLocalRepository(localRepo, localRepo);
            merged = true;
        } catch (Exception e) {
            throw new RepositoryException(e.getMessage(), e);
        }
    }

    @Override
    public boolean isMerged() {
        return merged;
    }

    @Override
    public String getGroupId() {
        return emptify(metadata.getGroupId());
    }

            List<ToolchainModel> dominant, List<ToolchainModel> recessive, String recessiveSourceLevel) {
        Map<Object, ToolchainModel> merged = new LinkedHashMap<>();

        for (ToolchainModel dominantModel : dominant) {
            Object key = getToolchainModelKey(dominantModel);

            merged.put(key, dominantModel);
        }

        for (ToolchainModel recessiveModel : recessive) {

        Properties merged = new Properties();
        if (sourceDominant) {
            merged.putAll(target.getProperties());
            merged.putAll(source.getProperties());
        } else {
            merged.putAll(source.getProperties());
            merged.putAll(target.getProperties());
        }
        target.setProperties(merged);
        target.setLocation(