expect:
        action.execute()
    }

    void appliesScriptsToDefaultTargetObject() {
        given:
        1 * resolver.resolveUri('script') >> file
        1 * parentCompileScope.createChild("script-$file", null) >> scriptCompileScope
        1 * scriptHandlerFactory.create(_, scriptCompileScope) >> scriptHandler

    }

    def testCreateGoogleRepo() {
        given:
        def googleUrl = new URI(DefaultRepositoryHandler.GOOGLE_URL)

        when:
        fileResolver.resolveUri(DefaultRepositoryHandler.GOOGLE_URL) >> googleUrl

        then:
        def repo = factory.createGoogleRepository()
        repo instanceof DefaultMavenArtifactRepository
        repo.url == googleUrl
    }

        }
        return repo;
    }

    // Mix in to Groovy DSL
    public VersionControlRepository gitRepository(String uri) {
        return gitRepository(fileResolver.resolveUri(uri));
    }

    @Override
    public void gitRepository(URI url, Action<? super VersionControlRepository> configureAction) {
        configureAction.execute(gitRepository(url));
    }

    @Nullable
    LocallyAvailableExternalResource resolveResource(ExternalResourceName resource);

    @Nullable
    LocallyAvailableExternalResource resolveUri(URI resource);

        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) {

        int pos = rawPattern.indexOf('[');
        String basePath = pos < 0 ? rawPattern : rawPattern.substring(0, pos);
        this.baseUri = fileResolver.resolveUri(basePath);
        this.pattern = pos < 0 ? "" : rawPattern.substring(pos);
        scheme = baseUri.getScheme().toLowerCase();
        absolutePattern = constructAbsolutePattern(baseUri, pattern);
    }

@ServiceScope({Scope.Global.class, Scope.BuildSession.class, Scope.Project.class})
public interface FileResolver extends RelativeFilePathResolver, PathToFileResolver {
    File resolve(Object path, PathValidation validation);

    URI resolveUri(Object path);

    NotationParser<Object, File> asNotationParser();

    @Override
    FileResolver newResolver(File baseDir);

    private final RelativeFilePathResolver resolver;

    public CachingTextUriResourceLoader(ExternalResourceAccessor externalResourceAccessor, Set<String> cachedSchemes, RelativeFilePathResolver resolver) {
        this.externalResourceAccessor = externalResourceAccessor;
        this.cachedSchemes = cachedSchemes;
        this.resolver = resolver;
    }

    @Override

            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:

        this.repositoryType = repositoryType;
        this.displayNameSupplier = displayNameSupplier;
    }

    @Override
    public URI getUrl() {
        return url == null ? null : fileResolver.resolveUri(url);
    }

    @Override
    public void setUrl(URI url) {
        this.url = url;
    }

    @Override
    public void setUrl(Object url) {
        this.url = url;
    }

    @Override