given:
        ResolverResults delegateResults = Mock()
        resolveContext.hasDependencies() >> true

        when:
        def results = dependencyResolver.resolveGraph(resolveContext)

        then:
        1 * delegate.resolveGraph(resolveContext) >> delegateResults
        results == delegateResults
    }

        resolver.resolveGraph(configuration) >> graphResolved(fileSet)

        when:
        def files = configuration.files(closure)

        then:
        files == fileSet
        configuration.state == RESOLVED
    }

    def "multiple resolves use cached result"() {
        given:
        def configuration = conf()
        resolver.resolveGraph(configuration) >> graphResolved()

        );
    }

    @Override
    public ResolverResults resolveGraph(ResolveContext resolveContext) throws ResolveException {
        if (resolveContext.hasDependencies()) {
            return delegate.resolveGraph(resolveContext);
        }

        if (resolveContext.getResolutionStrategy().isDependencyLockingEnabled()) {

    /**
     * Traverses the full dependency graph of the given resolve context. All failures are packaged in the result.
     */
    ResolverResults resolveGraph(ResolveContext resolveContext) throws ResolveException;

    /**
     * Returns the list of repositories available to resolve a given resolve context.
     */
    List<ResolutionAwareRepository> getAllRepositories();

        );

        return DefaultResolverResults.buildDependenciesResolved(graphResults, visitedArtifacts, legacyResolverResults);
    }

    @Override
    public ResolverResults resolveGraph(ResolveContext resolveContext) {
        StoreSet stores = storeFactory.createStoreSet();

        BinaryStore oldModelStore = stores.nextBinaryStore();

                runDependencyActions();
                runBeforeResolve();

                ResolverResults results;
                try {
                    results = resolver.resolveGraph(DefaultConfiguration.this);
                } catch (Exception e) {
                    throw exceptionMapper.mapFailure(e, "dependencies", displayName.getDisplayName());
                }

        includeBuild buildB, """
            substitute module("org.test:buildB") using project(":")
            substitute module("org.test:b1:1.0") using project(":b1")
"""

        expect:
        resolvedGraph {
            edge("org.test:buildB:1.0", ":buildB", "org.test:buildB:2.0") {
                compositeSubstitute()
                configuration = "runtimeElements"
            }

"""

        when:
        buildC.buildFile << """
            throw new RuntimeException('Configuration fails')
"""


        then:
        resolvedGraph {
            edge("org.test:buildB:1.0", ":buildB", "org.test:buildB:2.0") {
                compositeSubstitute()
            }
        }
    }

    deps.add project.dependencies.create("org:bar:1.0")
}
configurations.compile.withDependencies { deps ->
    assert deps.empty : "Compile dependencies should be empty"
}
"""

        then:
        resolvedGraph {
            module("org:foo:1.0")
            module("org:bar:1.0")
        }
    }

    def "can use withDependencies to mutate declared dependencies"() {
        when:
        buildFile << """

    private Set<Artifact> requestedArtifacts;

    private Set<Artifact> artifacts;

    private MetadataGraph dirtyTree;

    private MetadataGraph resolvedTree;

    private MetadataGraph resolvedGraph;

    public Artifact getOriginatingArtifact() {
        return originatingArtifact;
    }

    public MetadataResolutionResult listOriginatingArtifact(final Artifact originatingArtifact) {