Updates SourceBufferingInputStream to conform to InputStream contract

picasso/src/main/java/com/squareup/picasso3/SourceBufferingInputStream.java

@@ -21,6 +21,8 @@
 import okio.Buffer;
 import okio.BufferedSource;
 
+import static com.squareup.picasso3.Utils.checkNotNull;
+
 /**
  * An {@link InputStream} that fills the buffer of an {@link BufferedSource} as reads are requested
  * and copies its bytes into the byte arrays of the caller. This allows you to read as much of the
@@ -33,33 +35,49 @@ final class SourceBufferingInputStream extends InputStream {
   private final Buffer buffer;
   private long position;
   private long mark = -1;
+  private long markLimit = -1;
 
   SourceBufferingInputStream(BufferedSource source) {
     this.source = source;
     this.buffer = source.buffer();
   }
 
   private final Buffer temp = new Buffer();
+  // offset is the write offset in the dest array
   private int copyTo(byte[] sink, int offset, int byteCount) {
     // TODO replace this with https://github.com/square/okio/issues/362
-    buffer.copyTo(temp, offset, byteCount);
+    buffer.copyTo(temp, position, byteCount);
     return temp.read(sink, offset, byteCount);
   }
 
   @Override public int read() throws IOException {
-    source.require(position + 1);
+    if (!source.request(position + 1)) {
+      return -1;
+    }
     byte value = buffer.getByte(position++);
-    if (position > mark) {
+    if (position > markLimit) {
       mark = -1;
     }
     return value;
   }
 
   @Override public int read(@NonNull byte[] b, int off, int len) throws IOException {
-    source.require(position + len);
-    int copied = /*buffer.*/copyTo(b, off, len);
+    checkNotNull(b, "b is null");
+    if (off < 0 || len < 0 || len > b.length - off) {
+      throw new IndexOutOfBoundsException();
+    } else if (len == 0) {
+      return 0;
+    }
+
+    int count = len;
+    if (!source.request(position + count)) {
+      count = available();
+    }
+    if (count == 0) return -1;
+
+    int copied = /*buffer.*/copyTo(b, off, count);
     position += copied;
-    if (position > mark) {
+    if (position > markLimit) {
       mark = -1;
     }
     return copied;
@@ -68,7 +86,7 @@ private int copyTo(byte[] sink, int offset, int byteCount) {
   @Override public long skip(long n) throws IOException {
     source.require(position + n);
     position += n;
-    if (position > mark) {
+    if (position > markLimit) {
       mark = -1;
     }
     return n;
@@ -79,7 +97,8 @@ private int copyTo(byte[] sink, int offset, int byteCount) {
   }
 
   @Override public void mark(int readlimit) {
-    mark = position + readlimit;
+    mark = position;
+    markLimit = position + readlimit;
   }
 
   @Override public void reset() throws IOException {
@@ -88,6 +107,7 @@ private int copyTo(byte[] sink, int offset, int byteCount) {
     }
     position = mark;
     mark = -1;
+    markLimit = -1;
   }
 
   @Override public int available() {

picasso/src/test/java/com/squareup/picasso3/SourceBufferingInputStreamTest.java

@@ -10,7 +10,9 @@
 import okio.Timeout;
 import org.junit.Test;
 
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
 
 public final class SourceBufferingInputStreamTest {
   @Test public void replay() throws IOException {
@@ -45,6 +47,61 @@ public final class SourceBufferingInputStreamTest {
     assertEquals(13, stream.available());
   }
 
+  @Test public void read() throws IOException {
+    Buffer data = new Buffer().writeUtf8("Hello, world!");
+    BufferedSource source = Okio.buffer((Source) data);
+    InputStream stream = new SourceBufferingInputStream(source);
+    byte[] bytes = new byte[5];
+    int len = stream.read(bytes);
+    assertEquals(5, len);
+    assertArrayEquals(new byte[] {'H', 'e', 'l', 'l', 'o'}, bytes);
+
+    len = stream.read(bytes);
+    assertEquals(5, len);
+    assertArrayEquals(new byte[] {',', ' ', 'w', 'o', 'r'}, bytes);
+
+    len = stream.read(bytes);
+    assertEquals(3, len);
+    // last two bytes are out of range so untouched from previous run
+    assertArrayEquals(new byte[] {'l', 'd', '!', 'o', 'r'}, bytes);
+
+    len = stream.read(bytes);
+    assertEquals(-1, len);
+  }
+
+  @Test public void markReset() throws IOException {
+    Buffer data = new Buffer().writeUtf8("Hello, world!");
+    BufferedSource source = Okio.buffer((Source) data);
+    InputStream stream = new SourceBufferingInputStream(source);
+    stream.mark(2);
+
+    byte[] bytes = new byte[4];
+    int len = stream.read(bytes, 0, 2);
+    assertEquals(2, len);
+    assertArrayEquals(new byte[] {'H', 'e', 0, 0}, bytes);
+
+    len = stream.read(bytes);
+    assertEquals(len, 4);
+    assertArrayEquals(new byte[] {'l', 'l', 'o', ','}, bytes);
+
+    try {
+      stream.reset();
+      fail("expected IOException on reset");
+    } catch (IOException e) {
+      // success
+    }
+
+    stream.mark(2);
+    len = stream.read(bytes, 0, 2);
+    assertEquals(2, len);
+    assertArrayEquals(new byte[] {' ', 'w', 'o', ','}, bytes);
+
+    stream.reset();
+    len = stream.read(bytes);
+    assertEquals(4, len);
+    assertArrayEquals(new byte[] {' ', 'w', 'o', 'r'}, bytes);
+  }
+
   /** Prevents a consumer from reading large chunks and exercises edge cases. */
   private static final class OneByteSource implements Source {
     private final Source upstream;