return localFile.withContent(readAction);
    }

    @Override
    @Nullable
    public <T> ExternalResourceReadResult<T> withContentIfPresent(ContentAction<? extends T> readAction) throws ResourceException {
        return localFile.withContentIfPresent(readAction);
    }

    @Override

        ExternalResourceReadResult<T> result = withContentIfPresent(readAction);
        if (result == null) {
            throw ResourceExceptions.getMissing(getURI());
        }
        return result;
    }

    @Override
    public <T> ExternalResourceReadResult<T> withContent(ContentAndMetadataAction<? extends T> readAction) {
        ExternalResourceReadResult<T> result = withContentIfPresent(readAction);
        if (result == null) {

        def resource = new AccessorBackedExternalResource(name, resourceAccessor, resourceUploader, resourceLister, true)

        when:
        expectResourceRead(name, "1234")
        def result = resource.withContentIfPresent(action)

        then:
        result.result == "result 1"
        result.bytesRead == 4
        1 * action.execute(_) >> { InputStream input -> input.text; "result 1" }
        0 * _

        when:

        def file = tmpDir.createFile("content")
        file.text = "1234"

        expect:
        def resource = new LocalFileStandInExternalResource(file, TestFiles.fileSystem())
        def result = resource.withContentIfPresent(new ExternalResource.ContentAndMetadataAction<String>() {
            @Override
            String execute(InputStream inputStream, ExternalResourceMetaData metaData) throws IOException {

        throw new UnsupportedOperationException();
    }

    @Nullable
    @Override
    public <T> ExternalResourceReadResult<T> withContentIfPresent(ContentAction<? extends T> readAction) throws ResourceException {
        return accessor.withContent(name, revalidate, inputStream -> {

        1 * repository.resource(new ExternalResourceName("thing.sha1"), true) >> remoteSha1
        1 * remoteSha1.withContentIfPresent(_) >> null
        1 * repository.withProgressLogging() >> progressLoggingRepo
        1 * progressLoggingRepo.resource(location, true) >> remoteResource
        1 * remoteResource.withContentIfPresent(_) >> { ExternalResource.ContentAndMetadataAction a ->
            a.execute(new ByteArrayInputStream(), remoteMetaData)

     *
     * @return null if the resource does not exist.
     * @throws ResourceException on failure to read the content.
     */
    @Nullable
    <T> ExternalResourceReadResult<T> withContentIfPresent(ContentAction<? extends T> readAction) throws ResourceException;

    /**
     * Executes the given action against the binary contents and meta-data of this resource.

    def "can read file"() {
        def file = tmpDir.createFile("content")
        file.text = "1234"

        expect:
        def resource = UrlExternalResource.open(file.toURI().toURL())
        resource.withContentIfPresent(new ExternalResource.ContentAndMetadataAction() {
            @Override
            String execute(InputStream inputStream, ExternalResourceMetaData metaData) throws IOException {

        } catch (IOException e) {
            throw ResourceExceptions.getFailed(getURI(), e);
        }
    }

    @Nullable
    @Override
    public <T> ExternalResourceReadResult<T> withContentIfPresent(ContentAndMetadataAction<? extends T> readAction) throws ResourceException {
        if (!localFile.exists()) {
            return null;
        }
        try {

            ExternalResourceName sha1Location = location.append(".sha1");
            ExternalResource resource = delegate.resource(sha1Location, revalidate);
            ExternalResourceReadResult<HashCode> result = resource.withContentIfPresent(inputStream -> {
                String sha = IOUtils.toString(inputStream, StandardCharsets.US_ASCII);
                // Servers may return SHA-1 with leading zeros stripped