* {@link DependencyResolutionRequest#getResolutionFilter()}. This list is a union of the results from
     * {@link #getResolvedDependencies()} and {@link #getUnresolvedDependencies()}.
     *
     * @return The transitive dependencies, never {@code null}.
     */
    List<Dependency> getDependencies();

    /**
     * Gets the dependencies that were successfully resolved.
     *

                }
                if (artifacts.getFailures().isEmpty()) {
                    continue;
                }
                for (UnresolvedDependencyResult unresolvedDependency : getUnresolvedDependencies(configuration, visitor)) {
                    unresolvedDependencies.put(unresolvedDependency.getAttempted(), unresolvedDependency);
                }
            }
        }

        }
    }

    @Override
    public MinimalResolutionResult getResolutionResult() {
        return resolutionResult;
    }

    @Override
    public Set<UnresolvedDependency> getUnresolvedDependencies() {
        return unresolvedDependencies;
    }

    @Override
    public Optional<ResolveException> getResolutionFailure() {
        return Optional.ofNullable(resolutionFailure);
    }

    /**
     * Returns all failures to resolve a dependency.
     * These failures are also accessible via the resolution result.
     */
    Set<UnresolvedDependency> getUnresolvedDependencies();

    /**
     * Returns an optional failure describing an error that occurred during resolution.
     * This failure does not encompass unresolved dependencies and is _not_ captured in the resolution result.

            IdeaDependenciesVisitor visitor = visitDependencies(ideaModule, scope);
            dependencies.addAll(visitor.getDependencies());
            unresolvedDependencies.putAll(visitor.getUnresolvedDependencies());
        }
        optimizer.optimizeDeps(dependencies);
        new UnresolvedIdeDependencyHandler().log(unresolvedDependencies.values());
        return dependencies;
    }

        StringBuilder msg = new StringBuilder(message);
        msg.append(System.lineSeparator());
        for (Dependency dependency : result.getUnresolvedDependencies()) {
            msg.append("dependency: ").append(dependency).append(System.lineSeparator());
            List<Exception> exceptions = result.getResolutionErrors(dependency);
            for (Exception e : exceptions) {

    }

    public void addResolvedDependency(Dependency dependency) {
        dependencies.add(dependency);
        resolvedDependencies.add(dependency);
    }

    public List<Dependency> getUnresolvedDependencies() {
        return unresolvedDependencies;
    }

    public List<Exception> getCollectionErrors() {
        return collectionErrors;
    }

            if (aggregating && areAllDependenciesInReactor(session.getProjects(), result.getUnresolvedDependencies())) {
                logger.warn("The following dependencies could not be resolved at this point of the build"
                        + " but seem to be part of the reactor:");

                for (Dependency dependency : result.getUnresolvedDependencies()) {
                    logger.warn("o {}", dependency);
                }

        return implicitSelectionSpec;
    }

    @Override
    public Set<UnresolvedDependency> getUnresolvedModuleDependencies() {
        return graphResults.getUnresolvedDependencies();
    }

    private TransientConfigurationResults loadTransientGraphResults(SelectedArtifactResults artifactResults) {
        return transientConfigurationResultsFactory.create(artifactResults);
    }

        def root
        def components = new LinkedHashSet()
        final Map<ComponentSelector, FailureDetails> failures = new LinkedHashMap<>()

        Set<ComponentSelector> getUnresolvedDependencies() {
            return failures.keySet()
        }

        @Override
        void start(RootGraphNode root) {
            this.root = root
        }

        @Override