}

    private TestFile expectPathResolved(String path) {
        TestFile file = tmpDir.file(path)
        resolver.resolve(path) >> file
        return file
    }

    private URI expectPathResolvedToUri(String path) {
        TestFile file = tmpDir.file(path)
        resolver.resolveUri(path) >> file.toURI()
        return file.toURI()
    }

    private TestFile expectTempFileCreated() {

            new VersionParser()

        )
    }

    def "creates local repository"() {
        given:
        def file = new File('repo')
        def uri = file.toURI()
        _ * resolver.resolveUri('repo-dir') >> uri
        transportFactory.createTransport('file', 'repo', _, _) >> transport()

        and:
        repository.name = 'repo'
        repository.url = 'repo-dir'

        when:

import org.gradle.internal.component.model.ComponentOverrideMetadata;
import org.gradle.internal.resolve.resolver.ComponentMetaDataResolver;
import org.gradle.internal.resolve.result.BuildableComponentResolveResult;

/**
 * A component metadata resolver which should be used first in chain of resolvers as it will make sure
 * that we never "find" a virtual component, by shortcutting resolution if we find the marker interface

    @Nullable
    LocallyAvailableExternalResource resolveResource(ExternalResourceName resource);

    @Nullable
    LocallyAvailableExternalResource resolveUri(URI resource);

 */
public interface DependencyCoordinateResolverFactory {

    /**
     * Create coordinate resolvers for the given variant.
     */
    Provider<DependencyResolvers> createCoordinateResolvers(SoftwareComponentVariant variant, VersionMappingStrategyInternal versionMappingStrategy);

    /**
     * Contains the variant and component coordinate resolver for a given variant.
     */
    class DependencyResolvers {

    public DefaultObjectConfigurationAction(FileResolver resolver, ScriptPluginFactory configurerFactory,
                                            ScriptHandlerFactory scriptHandlerFactory, ClassLoaderScope classLoaderScope,
                                            TextUriResourceLoader.Factory textUriFileResourceLoaderFactory, Object defaultTarget) {
        this.resolver = resolver;
        this.configurerFactory = configurerFactory;

        ComponentDependencyResolver resolver
    ) {
        if (dependency instanceof ProjectDependency) {
            ResolvedCoordinates identifier = resolver.resolveComponentCoordinates((ProjectDependency) dependency);
            return projectDependencyCoordinatesFor(identifier);
        } else if (dependency instanceof ExternalDependency) {

import org.gradle.internal.reflect.Instantiator;
import org.gradle.internal.resolve.caching.ComponentMetadataSupplierRuleExecutor;
import org.gradle.internal.resolve.resolver.ArtifactResolver;
import org.gradle.internal.resolve.resolver.ComponentMetaDataResolver;
import org.gradle.internal.resolve.resolver.DependencyToComponentIdResolver;
import org.gradle.internal.resolve.result.BuildableArtifactResolveResult;

 *
 * <p>The resolvers in a container are accessible as read-only properties of the container, using the name of the
 * resolver as the property name. For example:</p>
 *
 * <pre class='autoTested'>
 * repositories.maven { name 'myResolver' }
 * repositories.myResolver.url = 'some-url'
 * </pre>
 *

        this.fileStore = fileStore;
        this.resourceAccessor = resourceAccessor;
    }

    @Nullable
    @Override
    public LocallyAvailableExternalResource resolveUri(URI uri) {
        return resolve(new ExternalResourceName(uri));
    }

    @Nullable
    @Override
    public LocallyAvailableExternalResource resolveResource(ExternalResourceName resource) {