*/
@NonNullApi
public class ExternalResourceName implements Describable {
    @Nullable
    private final String encodedRoot;
    private final String path;
    private final String encodedQuery;

    public ExternalResourceName(URI uri) {
        this(encodeRoot(uri), extractPath(uri), extractQuery(uri));
    }

    public ExternalResourceName(String path) {
        this(null, path, "");
    }

        0 * _
    }

    def expectResourceRead(ExternalResourceName name, String content) {
        1 * resourceAccessor.withContent(name, true, _) >> { uri, revalidate, action ->
            action.execute(new ByteArrayInputStream(content.bytes))
        }
    }

    def expectResourceRead(ExternalResourceName name, ExternalResourceMetaData metaData, String content) {

    @Nullable
    @Override
    public <T> T withContent(ExternalResourceName location, boolean revalidate, ExternalResource.ContentAndMetadataAction<T> action) throws ResourceException {
        return buildOperationRunner.call(new DownloadOperation<>(location, revalidate, action));
    }

    @Override
    @Nullable
    public ExternalResourceMetaData getMetaData(ExternalResourceName location, boolean revalidate) {

    }

    private List<String> filterOutMatchesWithOverlappingPatterns(List<String> listedVersions, ExternalResourceName currentVersionListPattern, Collection<ExternalResourceName> versionListPatterns) {
        List<String> remaining = Lists.newArrayList(listedVersions);
        for (ExternalResourceName otherVersionListPattern : versionListPatterns) {
            if (otherVersionListPattern != currentVersionListPattern) {

        if (startParameter.isOffline) {
            true
        } else {
            val externalResourceName = ExternalResourceName(uri)

            val cached = cachedExternalResourceIndex.lookup(externalResourceName.toString())
            val remoteMetaData = externalResourceConnector.getMetaData(externalResourceName, true)

        }
        UrlExternalResource connector = new UrlExternalResource();
        return new AccessorBackedExternalResource(new ExternalResourceName(uri), connector, connector, connector, false);
    }

    @Nullable
    @Override
    public ExternalResourceMetaData getMetaData(ExternalResourceName location, boolean revalidate) throws ResourceException {
        try {
            URL url = location.getUri().toURL();

            // not the same provider
            return false;
        }
        ExternalResourceName externalResourceName = new ExternalResourceName(rootUri, parts[1]);
        LocallyAvailableExternalResource locallyAvailableExternalResource = resourceResolver.resolveResource(externalResourceName);
        return Objects.equal(oldValue, hashFor(locallyAvailableExternalResource));
    }

    @NonNullApi
    private static class SnapshotMetadataResult {
        public final ExternalResourceName snapshotMetadataPath;
        public final Metadata snapshotMetadata;

        public SnapshotMetadataResult(ExternalResourceName snapshotMetadataPath, Metadata snapshotMetadata) {

    }

    def "list returns null if HttpAccessor returns null"(){
        setup:
        accessorMock.openResource(new ExternalResourceName("http://testrepo/"), true)  >> null
        expect:
        null == lister.list(new ExternalResourceName("http://testrepo"))
    }

        return pattern;
    }

    @Override
    public ExternalResourceName toVersionListPattern(ModuleIdentifier module, IvyArtifactName artifact) {
        Map<String, String> attributes = toAttributes(module, artifact);
        return getBase().getRoot().resolve(substituteTokens(getBase().getPath(), attributes));
    }

    @Override
    public ExternalResourceName toModulePath(ModuleIdentifier module) {