return configuration;
    }

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

    public void setGoal(String goal) {
        this.goal = goal;
    }

    public void setConfiguration(XmlNode configuration) {
        this.configuration = configuration;
    }

    public void setDependencies(List<Dependency> dependencies) {
        this.dependencies = dependencies;
    }

    }

    public void setArtifactExists(boolean artifactExists) {
        this.artifactExists = artifactExists;
    }

    public Collection<ArtifactMetadata> getDependencies() {
        return dependencies;
    }

    public void setDependencies(Collection<ArtifactMetadata> dependencies) {
        this.dependencies = dependencies;
    }

    public String getArtifactUri() {
        return artifactUri;
    }

                for (Dependency dependency : source.getDependencies()) {
                    String key = dependency.getManagementKey();
                    if (!dependencies.containsKey(key)) {
                        dependencies.put(key, dependency);
                    }
                }
            }

            depMgmt.setDependencies(new ArrayList<>(dependencies.values()));
        }
    }

        d1.setGroupId("myGroupId");
        assertNotNull(dm.getDependencies());
        assertEquals(0, dm.getDependencies().size());
        dm.addDependency(d1);
        assertNotNull(dm.getDependencies());
        assertEquals(1, dm.getDependencies().size());
        dm.getDependencies().get(0).setArtifactId("myArtifactId");
        assertEquals("myArtifactId", dm.getDependencies().get(0).getArtifactId());
        dm.setDependencies(null);

            Configuration compileOnly = project.getConfigurations()
                .getByName(CompileOnlyResolvePlugin.RESOLVEABLE_COMPILE_ONLY_CONFIGURATION_NAME);
            t.setDependencies(
                runtimeClasspath.fileCollection(dependency -> dependency instanceof ProjectDependency == false).minus(compileOnly)
            );
        });

         */
        List<Dependency> dependencies = model.getDependencies();
        Map<String, Dependency> normalized = new LinkedHashMap<>(dependencies.size() * 2);

        for (Dependency dependency : dependencies) {
            normalized.put(dependency.getManagementKey(), dependency);
        }

        if (dependencies.size() != normalized.size()) {
            model.setDependencies(new ArrayList<>(normalized.values()));
        }
    }

                    execution.setConfiguration(new Xpp3Dom(lifecycleConfiguration));
                }

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

    private GoalSpec parseGoalSpec(String goalSpec) {

        Model merged = mavenMerger.merge(target, source, true, null);

        assertEquals(1, merged.getDependencies().size(), "Expected exactly 1 dependency");
        assertTrue(
                merged.getDependencies().contains(dependency),
                "Expected dependencies to contain " + dependency + " but was " + merged.getDependencies());
    }

            DependencyManagement source,
            boolean sourceDominant,
            Map<Object, Object> context) {
        Iterator<Dependency> sourceIterator = source.getDependencies().iterator();
        builder.dependencies(target.getDependencies().stream()
                .map(d -> mergeDependency(d, sourceIterator.next(), sourceDominant, context))
                .collect(Collectors.toList()));
    }

    @Override

    public void apply(Project project) {
        Attribute<Boolean> jdkAttribute = Attribute.of("jdk", Boolean.class);
        project.getDependencies().getAttributesSchema().attribute(jdkAttribute);
        project.getDependencies().getArtifactTypes().maybeCreate(ArtifactTypeDefinition.ZIP_TYPE);
        project.getDependencies().registerTransform(UnzipTransform.class, transformSpec -> {
            transformSpec.getFrom()