import java.io.IOException;
import java.io.InputStream;
import java.io.UncheckedIOException;

public class DefaultFileHasher implements FileHasher {
    private final StreamHasher streamHasher;

    public DefaultFileHasher(StreamHasher streamHasher) {
        this.streamHasher = streamHasher;
    }

    @Override
    public HashCode hash(File file) {
        InputStream inputStream;
        try {

            throw new IORuntimeException(e);
        }
    }

    /**
     * {@link InputStream}をリセットします。
     *
     * @param is
     *            入力ストリーム。{@literal null}であってはいけません
     * @see InputStream#reset()
     */
    public static void reset(final InputStream is) {
        assertArgumentNotNull("is", is);

        try {
            is.reset();
        } catch (final IOException e) {

     *
     * @param inputStream The input stream to hash
     * @return An {@link Optional} containing the {@link HashCode} or empty if the file is binary
     * @throws IOException
     */
    public Optional<HashCode> hashContent(InputStream inputStream) throws IOException {
        return hash(inputStream);
    }

    /**

            assert content == [0xc4, 0xc5, 0xc6] as byte[]

            assert decoder.inputStream.read() == -1
            assert decoder.inputStream.read(buffer) == -1
            assert decoder.inputStream.read(buffer, 0, 1) == -1
        }
    }

    def "ignores close on InputStream"() {
        def inputStream = Mock(InputStream)

        when:
        decodeFrom(inputStream) { Decoder decoder ->

        then:
        1 * resource.open() >> inputStream
        1 * resource.contentLength >> 1072
        1 * delegate.upload(_, location) >> { resource, destination ->
            def stream = resource.open();
            assert stream.read(new byte[1024]) == 1024
            assert stream.read(new byte[1024]) == 48
        }
        1 * inputStream.read(_, 0, 1024) >> 1024
        1 * inputStream.read(_, 0, 1024) >> 48

    }

    public static StreamByteBuffer of(InputStream inputStream) throws IOException {
        StreamByteBuffer buffer = new StreamByteBuffer(chunkSizeInDefaultRange(inputStream.available()));
        buffer.readFully(inputStream);
        return buffer;
    }

    public static StreamByteBuffer of(InputStream inputStream, int len) throws IOException {

            String execute(InputStream inputStream, ExternalResourceMetaData metaData) throws IOException {
                assert metaData.location.toASCIIString() == file.toURI().toASCIIString()
                assert metaData.lastModified == new Date(file.lastModified())
                assert metaData.contentLength == 4
                assert metaData.sha1 == null
                assert inputStream.text == "1234"

            }
            throw e
        }
        return outerCloseable
    }

    private
    fun decryptingInputStream(inputStream: InputStream): InputStream {
        val cipher = newEncryptionSession().decryptingCipher(inputStream::read)
        return CipherInputStream(inputStream, cipher)
    }

    private
    fun encryptingOutputStream(outputStream: OutputStream): OutputStream {

        return withInputStream(new IoFunction<InputStream, byte[]>() {
            @Override
            public byte[] apply(InputStream inputStream) throws IOException {
                int size = size();
                if (size >= 0) {
                    byte[] content = new byte[size];
                    ByteStreams.readFully(inputStream, content);
                    return content;
                } else {

import org.gradle.internal.serialize.kryo.KryoBackedEncoder;

import java.io.InputStream;
import java.io.OutputStream;

public class KryoBackedMessageSerializer implements MessageSerializer {
    @Override
    public Decoder newDecoder(InputStream inputStream) {
        return new KryoBackedDecoder(inputStream);
    }

    @Override
    public FlushableEncoder newEncoder(OutputStream outputStream) {