dep2.setArtifactId( "test-artifact2" );
        dep2.setVersion( "1" );
        dep2.setType( "jar" );

        List<Dependency> deps = new ArrayList<>();
        deps.add( dep1 );
        deps.add( dep2 );

        ArtifactFactory factory = container.lookup( ArtifactFactory.class );

        ArtifactFilter dependencyFilter = new ScopeArtifactFilter( Artifact.SCOPE_COMPILE );

        assertNotNull(result);
        List<Dependency> deps = new ArrayList<>(result.getDependencies().keySet());
        List<Dependency> deps2 = result.getNodes().stream()
                .map(Node::getDependency)
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
        assertEquals(deps, deps2);
        for (Dependency dep : deps2) {
            dep.getVersion();
        }
    }

        assertEquals(
                "excluded-managed-dep", pom.getValue("dependencyManagement/dependencies[1]/exclusions[1]/artifactId"));

        assertEquals(1, ((List<?>) pom.getValue("dependencies")).size());
        assertEquals("org.apache.maven.its", pom.getValue("dependencies[1]/groupId"));
        assertEquals("dep", pom.getValue("dependencies[1]/artifactId"));

            version = project.getVersion();

            Set<String> deps = new LinkedHashSet<>();
            if (project.getDependencyArtifacts() != null) {
                for (Artifact dep : project.getDependencyArtifacts()) {
                    deps.add(dep.toString());
                }
            }
            dependencyArtifacts = Collections.unmodifiableSet(deps);

            workspace = RepositoryUtils.getWorkspace(session);

        assertTrue(a.getScope().equals("test"), "Incorrect scope for " + a.getDependencyConflictId());

        // transitive dep, overridden b depMgmt
        assertTrue(b.getScope().equals("runtime"), "Incorrect scope for " + b.getDependencyConflictId());

        // direct dep, overrides depMgmt
        assertTrue(c.getScope().equals("runtime"), "Incorrect scope for " + c.getDependencyConflictId());
    }

            return addDependency(id, version, scope, false);
        }

        private ArtifactSpec addDependency(ArtifactSpec dep) throws InvalidVersionSpecificationException {
            if (dep != null) {
                dependencies.add(dep.artifact);
            }
            return dep;
        }

        private ArtifactSpec addDependency(String id, String version, String scope, boolean optional)

        importIds.add(importing);

        List<DependencyManagement> importMgmts = null;

        List<Dependency> deps = new ArrayList<>(depMgmt.getDependencies());
        for (Iterator<Dependency> it = deps.iterator(); it.hasNext(); ) {
            Dependency dependency = it.next();

            if (!("pom".equals(dependency.getType()) && "import".equals(dependency.getScope()))

        MojoExecution exec = newMojoExecution();

        Artifact depArtifact = createArtifact("group", "artifact", "1");

        List<Artifact> deps = new ArrayList<>();
        deps.add(depArtifact);

        exec.getMojoDescriptor().getPluginDescriptor().setArtifacts(deps);

        MavenSession session = newMavenSession();

        @SuppressWarnings("unchecked")
        List<Artifact> depResults =

        List<Dependency> newDeps = new ArrayList<>();
        boolean modified = false;
        for (Dependency dep : model.getDependencies()) {
            if (dep.getVersion() == null) {
                Model depModel = context.getRawModel(model.getPomFile(), dep.getGroupId(), dep.getArtifactId());
                if (depModel != null) {
                    String v = depModel.getVersion();

     */
    void addDependency(Node node, Dependency dep, Predicate<PathType> filter, Path path, PathModularizationCache cache)
            throws IOException {
        nodes.add(node);
        if (dep == null) {
            return;
        }
        if (dependencies.put(dep, path) != null) {
            throw new IllegalStateException("Duplicated key: " + dep);
        }
        if (path == null) {
            return;