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);

            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

                for (Dependency dependency : model.getDependencies()) {
                    Object key = getDependencyKey().apply(dependency);
                    dependencies.put(key, dependency);
                }

                boolean modified = false;
                for (Dependency managedDependency : dependencyManagement.getDependencies()) {
                    Object key = getDependencyKey().apply(managedDependency);

         * the way 2.x works. When we're in strict mode, the removal of duplicates just saves other merging steps from
         * aftereffects and bogus error messages.
         */
        List<Dependency> dependencies = model.getDependencies();
        Map<String, Dependency> normalized = new LinkedHashMap<>(dependencies.size() * 2);

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

                }
            }
        });

        ModelBuildingResult result = builder.build(request);
        Dependency dep = result.getEffectiveModel().getDelegate().getDependencyManagement().getDependencies().stream()
                .filter(d -> "test:mydep:jar".equals(d.getManagementKey()))
                .findFirst()
                .get();
        assertEquals("0.2", dep.getVersion());

        return profile.getActivation() == null
                && profile.getBuild() == null
                && profile.getDependencies().isEmpty()
                && (profile.getDependencyManagement() == null
                        || profile.getDependencyManagement().getDependencies().isEmpty())
                && profile.getDistributionManagement() == null
                && profile.getModules().isEmpty()

        }

        if (model != null) {
            pomArtifact = artifact;
            dependencies = model.getDependencies();
            DependencyManagement dependencyManagement = model.getDependencyManagement();
            managedDependencies = dependencyManagement == null ? null : dependencyManagement.getDependencies();
            MavenSession session = legacySupport.getSession();
            if (session != null) {

            DependencyManagement depMgmt = target.getDependencyManagement();

            if (depMgmt != null) {
                for (Dependency dependency : depMgmt.getDependencies()) {
                    dependencies.put(dependency.getManagementKey(), dependency);
                }
            } else {
                depMgmt = DependencyManagement.newInstance();
            }

        assertFalse(pd.isIsolatedRealm());
        assertTrue(pd.isInheritedByDefault());
        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());

    public Path getBasedir() {
        return nonNull(project.getBasedir(), "basedir").toPath();
    }

    @Nonnull
    @Override
    public List<DependencyCoordinates> getDependencies() {
        return new MappedList<>(getModel().getDependencies(), this::toDependency);
    }

    @Nonnull
    @Override
    public List<DependencyCoordinates> getManagedDependencies() {