} else if (startParameter.isRefreshDependencies()) {
            cachePolicy.setRefreshDependencies();
        }
    }

    public ModuleComponentRepository<ModuleComponentResolveMetadata> overrideModuleVersionRepository(ModuleComponentRepository<ModuleComponentResolveMetadata> original) {
        if (startParameter.isOffline()) {
            return new OfflineModuleComponentRepository(original);
        }

public class RepositoryChainComponentMetaDataResolver implements ComponentMetaDataResolver {
    private static final Logger LOGGER = LoggerFactory.getLogger(RepositoryChainComponentMetaDataResolver.class);

    private final List<ModuleComponentRepository<ModuleComponentGraphResolveState>> repositories = new ArrayList<>();
    private final List<String> repositoryNames = new ArrayList<>();
    private final VersionedComponentChooser versionedComponentChooser;

    private final ModuleComponentRepository<ModuleComponentGraphResolveState> delegate;
    private final ErrorHandlingModuleComponentRepositoryAccess local;
    private final ErrorHandlingModuleComponentRepositoryAccess remote;

import java.util.Map;

public class FilteredModuleComponentRepository implements ModuleComponentRepository<ModuleComponentGraphResolveState> {
    private final ModuleComponentRepository<ModuleComponentGraphResolveState> delegate;
    private final Action<? super ArtifactResolutionDetails> filterAction;

    final cache = new HashMap()

    final repo1 = Stub(ModuleComponentRepository) {
        getId() >> "repo1"
    }

    final localAccess2 = Mock(ModuleComponentRepositoryAccess)
    final remoteAccess2 = Mock(ModuleComponentRepositoryAccess)
    final repo2 = Stub(ModuleComponentRepository) {
        getLocalAccess() >> localAccess2
        getRemoteAccess() >> remoteAccess2

import org.gradle.internal.resolve.result.BuildableModuleComponentMetaDataResolveResult;
import org.gradle.internal.resolve.result.BuildableModuleVersionListingResolveResult;

/**
 * A ModuleComponentRepository that wraps another, but assumes that _all_ access is local. This means that the accessor returned
 * by {@link #getLocalAccess()} will attempt both local _and_ remote access operations on the delegate.
 *

                        }
                    });
                }
            }
        });

    }

    @Override
    public ModuleComponentRepository<ModuleComponentGraphResolveState> overrideDependencyVerification(ModuleComponentRepository<ModuleComponentGraphResolveState> original) {
        return new DependencyVerifyingModuleComponentRepository(original, this, verifier.getConfiguration().isVerifySignatures());

 */

package org.gradle.api.internal.artifacts.ivyservice.ivyresolve

import spock.lang.Specification

class BaseModuleComponentRepositoryTest extends Specification {
    final delegate = Mock(ModuleComponentRepository)
    final localAccess = Mock(ModuleComponentRepositoryAccess)
    final remoteAccess = Mock(ModuleComponentRepositoryAccess)

    def "delegates id and name methods"() {
        when:

import java.io.File;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;

public class DependencyVerifyingModuleComponentRepository implements ModuleComponentRepository<ModuleComponentGraphResolveState> {
    private final ModuleComponentRepository<ModuleComponentGraphResolveState> delegate;
    private final ModuleComponentRepositoryAccess<ModuleComponentGraphResolveState> localAccess;

import org.gradle.internal.component.model.ModuleSource;

public class RepositoryChainModuleSource implements ModuleSource {
    private final String repositoryId;

    public RepositoryChainModuleSource(ModuleComponentRepository<?> repository) {
        this.repositoryId = repository.getId();
    }

    @Override
    public String toString() {
        return "{repo: " + repositoryId + "}";
    }