def results3 = new DefaultVisitedGraphResults(resolutionResult, Collections.emptySet(), Mock(ResolveException))

        expect:
        !results1.hasAnyFailure()
        results2.hasAnyFailure()
        results3.hasAnyFailure()
    }

    def "visits all resolution failures"() {
        given:
        def throwable = Mock(Throwable)
        def resolveEx = Mock(ResolveException)

public interface VisitedGraphResults {

    /**
     * Returns true if any failures occurred while building these results.
     */
    boolean hasAnyFailure();

    /**
     * Visits all failures that occurred while resolving the graph.
     *
     * <p>No failures are visited if {@link #hasAnyFailure()} is false</p>
     */
    void visitFailures(Consumer<Throwable> visitor);

    /**
     * Returns all failures to resolve a dependency.

        this.configuration = configuration;
    }

    @Override
    public boolean hasError() {
        return graphResults.hasAnyFailure();
    }

    @Override
    public void rethrowFailure() throws ResolveException {
        if (!graphResults.hasAnyFailure()) {
            return;
        }

        List<Throwable> failures = new ArrayList<>();
        graphResults.visitFailures(failures::add);

    ) {
        this.resolutionResult = resolutionResult;
        this.unresolvedDependencies = unresolvedDependencies;
        this.resolutionFailure = resolutionFailure;
    }

    @Override
    public boolean hasAnyFailure() {
        return !unresolvedDependencies.isEmpty() || resolutionFailure != null;
    }

    @Override
    public void visitFailures(Consumer<Throwable> visitor) {

        context.add(resolvedArtifacts);
    }

    @Override
    public void visitArtifacts(ArtifactVisitor visitor, boolean continueOnSelectionFailure) {
        if (graphResults.hasAnyFailure()) {
            graphResults.visitFailures(visitor::visitFailure);
            if (!continueOnSelectionFailure) {
                return;
            }
        }

        // Only write dependency locks if resolution completed without failure.
        if (lockingVisitor != null && !graphResults.hasAnyFailure()) {
            lockingVisitor.writeLocks();
        }

        ArtifactVariantSelector artifactVariantSelector = variantSelectorFactory.create(resolveContext.getDependenciesResolverFactory());

        if (!currentState.isPresent()) {
            return State.UNRESOLVED;
        }

        ResolverResults resolvedState = currentState.get();
        if (resolvedState.getVisitedGraph().hasAnyFailure()) {
            return State.RESOLVED_WITH_FAILURES;
        } else if (resolvedState.isFullyResolved()) {
            return State.RESOLVED;
        } else {
            return State.UNRESOLVED;
        }