microsoft-azure-storage/src/com/microsoft/azure/storage/file/FileInputStream.java
@Override
    @DoesServiceRequest
    public int read(final byte[] b, final int off, final int len) throws IOException {
        if (off < 0 || len < 0 || len > b.length - off) {
            throw new IndexOutOfBoundsException();
        }

        return this.readInternal(b, off, len);
    }
@Override
    @DoesServiceRequest
    public int read(final byte[] b, final int off, final int len) throws IOException {
        if (off < 0 || len < 0 || len > b.length - off) {
            throw new IndexOutOfBoundsException();
        }

        return this.readInternal(b, off, len);
    }
Reads up to <code>len</code> bytes of data from the input stream into an array of bytes. An attempt is made to
read as many as <code>len</code> bytes, but a smaller number may be read. The number of bytes actually read is
returned as an integer. This method blocks until input data is available, end of file is detected, or an
exception is thrown.

If <code>len</code> is zero, then no bytes are read and 0 is returned; otherwise, there is an attempt to read at
least one byte. If no byte is available because the stream is at end of file, the value -1 is returned;
otherwise, at least one byte is read and stored into <code>b</code>.

The first byte read is stored into element <code>b[off]</code>, the next one into <code>b[off+1]</code>, and so
on. The number of bytes read is, at most, equal to <code>len</code>. Let <code>k</code> be the number of bytes
actually read; these bytes will be stored in elements <code>b[off]</code> through <code>b[off+k-1]</code>,
leaving elements <code>b[off+k]</code> through <code>b[off+len-1]</code> unaffected.

In every case, elements <code>b[0]</code> through <code>b[off]</code> and elements <code>b[off+len]</code>
through <code>b[b.length-1]</code> are unaffected.

The <code>read(b, off, len)</code> method for class {@link InputStream} simply calls the method
<code>read()</code> repeatedly. If the first such call results in an <code>IOException</code>, that exception is
returned from the call to the <code>read(b, off, len)</code> method. If any subsequent call to
<code>read()</code> results in a <code>IOException</code>, the exception is caught and treated
as if it were end of file; the bytes read up to that point are stored into <code>b</code> and the number of bytes
read before the exception occurred is returned. The default implementation of this method blocks until the
requested amount of input data <code>len</code> has been read, end of file is detected, or an exception is
thrown. Subclasses are encouraged to provide a more efficient implementation of this method.

@param b
A <code>byte</code> array which represents the buffer into which the data is read.
@param off
An <code>int</code> which represents the start offset in the <code>byte</code> array at which the data
is written.
@param len
An <code>int</code> which represents the maximum number of bytes to read.

@return An <code>int</code> which represents the total number of bytes read into the buffer, or -1 if
there is no more data because the end of the stream has been reached.

@throws IOException
If the first byte cannot be read for any reason other than end of file, or if the input stream has
been closed, or if some other I/O error occurs.
@throws NullPointerException
If the <code>byte</code> array <code>b</code> is null.
@throws IndexOutOfBoundsException
If <code>off</code> is negative, <code>len</code> is negative, or <code>len</code> is greater than
<code>b.length - off</code>.