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

        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));
    }

    }

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

    }

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

    @Override
    public ExternalResourceName toVersionListPattern(ModuleIdentifier module, IvyArtifactName artifact) {

        return resolve(new ExternalResourceName(uri));
    }

    @Nullable
    @Override
    public LocallyAvailableExternalResource resolveResource(ExternalResourceName resource) {
        return resolve(resource);
    }

    @Nullable
    private LocallyAvailableExternalResource resolve(final ExternalResourceName resource) {
        LOGGER.debug("Loading {}", resource);

    };

    private class ListOperation implements CallableBuildOperation<List<String>> {
        private final ExternalResourceName parent;

        public ListOperation(ExternalResourceName parent) {
            this.parent = parent;
        }

        @Override
        public List<String> call(BuildOperationContext context) {
            try {

 * limitations under the License.
 */

package org.gradle.internal.resource.transport.http;

import org.gradle.internal.IoActions;
import org.gradle.internal.resource.ExternalResourceName;
import org.gradle.internal.resource.metadata.ExternalResourceMetaData;
import org.gradle.internal.resource.transfer.AbstractExternalResourceAccessor;
import org.gradle.internal.resource.transfer.ExternalResourceAccessor;