recordArtifacts = projectArtifactsCache.get(cacheKey);
                if (recordArtifacts == null) {
                    try {
                        Set<Artifact> resolvedArtifacts = getDependencies(
                                project, scopesToCollect, scopesToResolve, session, aggregating, projectArtifacts);
                        recordArtifacts = projectArtifactsCache.put(cacheKey, resolvedArtifacts);

    }

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

        return getSortedProjects(projectIds);
    }

    private void getUpstreamProjects(String projectId, Collection<String> projectIds, boolean transitive) {
        for (String id : sorter.getDependencies(projectId)) {
            if (projectIds.add(id) && transitive) {
                getUpstreamProjects(id, projectIds, transitive);
            }
        }
    }

    }

    @Override
    public Set<Artifact> createArtifacts(MavenProject project) throws InvalidDependencyVersionException {
        return createArtifacts(artifactFactory, project.getDependencies(), null, null, project);
    }

    public static Set<Artifact> createArtifacts(
            ArtifactFactory artifactFactory,
            List<Dependency> dependencies,
            String inheritedScope,

    /**
     * For the given {@link MavenProject} {@code p}, return all of {@code p}'s dependencies.
     *
     * @param p
     * @return List of prerequisite projects
     */
    protected List<MavenProject> getDependencies(MavenProject p) {
        return projectDependencyGraph.getUpstreamProjects(p, false);
    }

    /**
     * For the given {@link MavenProject} {@code p} return {@code p}'s uncompleted dependencies.
     *

                for (PluginExecution execution : plugin.getExecutions()) {
                    visit(execution);
                }
                // Dependencies
                for (Dependency dependency : plugin.getDependencies()) {
                    visit(dependency);
                }
            }
        }

        private void visit(PluginExecution execution) {
            if (execution != null) {

            return resolved;
        }

        /*

        Logic for transitive global exclusions

        List<String> exclusions = new ArrayList<String>();

        for ( Dependency d : project.getDependencies() )
        {
            if ( d.getExclusions() != null )
            {
                for ( Exclusion e : d.getExclusions() )
                {

        request.addRepository(newTestRepository());

        ArtifactDescriptorResult result = system.readArtifactDescriptor(session, request);

        List<Dependency> deps = result.getDependencies();
        assertEquals(2, deps.size());
        checkUtSimpleArtifactDependencies(deps.get(0), deps.get(1));
    }

    /**
     * check ut.simple:artifact:1.0 dependencies
     */

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

            plugin.setDependencies(new ArrayList<>(pluginInPom.getDependencies()));
        }
    }

    private Plugin findPlugin(Plugin plugin, Collection<Plugin> plugins) {
        return findPlugin(plugin.getGroupId(), plugin.getArtifactId(), plugins);
    }

        DependencyManagement dep = projectToClone.getDependencyManagement();
        assertNotNull(dep, "No dependencyManagement");
        List<?> list = dep.getDependencies();
        assertNotNull(list, "No dependencies");
        assertTrue(!list.isEmpty(), "Empty dependency list");

        Map<?, ?> map = projectToClone.getManagedVersionMap();