public ExternalResourceReadResult<Void> withContent(Action<? super InputStream> readAction) throws ResourceException {
        return localFile.withContent(readAction);
    }

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

    @Override
    @Nullable

    BinaryData done();

    interface WriteAction {
        void write(Encoder encoder) throws IOException;
    }

    interface ReadAction<T> {
        T read(Decoder decoder) throws IOException;
    }

    interface BinaryData extends Closeable {
        <T> T read(ReadAction<T> readAction);
    }

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

    @Override
    public <T> ExternalResourceReadResult<T> withContent(ContentAndMetadataAction<? extends T> readAction) {

    @Override
    public <T> ExternalResourceReadResult<T> withContentIfPresent(ContentAction<? extends T> readAction) throws ResourceException {
        return accessor.withContent(name, revalidate, inputStream -> {
            try (CountingInputStream input = new CountingInputStream(new BufferedInputStream(inputStream))) {
                T value = readAction.execute(input);
                return ExternalResourceReadResult.of(input.getCount(), value);

        def data = store.done()

        then:
        data.read({ it.readInt() } as BinaryStore.ReadAction) == 10
        data.read({ it.readString() } as BinaryStore.ReadAction) == "x"
        data.close()

        then:
        data.read({ it.readInt() } as BinaryStore.ReadAction) == 10
        data.read({ it.readString() } as BinaryStore.ReadAction) == "x"
        data.close()

        cleanup:
        store.close()

    }

    }

    BinaryData done() {
        new BinaryData() {
            Decoder decoder
            def <T> T read(ReadAction<T> readAction) {
                if (decoder == null) {
                    decoder = new InputStreamBackedDecoder(new ByteArrayInputStream(bytes.toByteArray()))
                }
                readAction.read(decoder)
            }

            void close() {
                decoder = null
            }

        if (!localFile.exists()) {
            throw ResourceExceptions.getMissing(getURI());
        }
        try {
            CountingInputStream input = new CountingInputStream(new BufferedInputStream(new FileInputStream(localFile)));
            try {
                readAction.execute(input);
            } finally {
                input.close();

     * @throws org.gradle.api.resources.MissingResourceException when the resource does not exist
     */
    @SuppressWarnings("overloads")
    ExternalResourceReadResult<Void> withContent(Action<? super InputStream> readAction) throws ResourceException;

    /**
     * Executes the given action against the binary contents of this resource.
     *
     * @throws ResourceException on failure to read the content.

        public SimpleBinaryData(File inputFile, long offset) {
            this.inputFile = inputFile;
            this.offset = offset;
        }

        @Override
        public <T> T read(BinaryStore.ReadAction<T> readAction) {
            try {
                if (decoder == null) {
                    RandomAccessFile randomAccess = new RandomAccessFile(inputFile, "r");
                    randomAccess.seek(offset);

                        resource(_ as ExternalResourceName) >> Mock(ExternalResource) {
                            withContent(_ as Action<? super InputStream>) >> { Action<? super InputStream> readAction ->
                                readAction.execute(new ByteArrayInputStream("foo".bytes))
                                doAfterRead()
                            }
                        }
                    }
                }