IO-568: AutoCloseInputStream should disable mark/reset

src/main/java/org/apache/commons/io/input/AutoCloseInputStream.java

@@ -32,6 +32,10 @@
  * stream as soon as possible even if the client application (by not explicitly
  * closing the stream when no longer needed) or the underlying stream (by not
  * releasing resources once the last byte has been read) do not do that.
+ * <p>
+ * Since the only way to always close the stream when reaching the end and
+ * respecting mark/reset contract, AutoCloseInputStream force disabling
+ * mark/reset.
  *
  * @since 1.4
  */
@@ -79,6 +83,44 @@ protected void afterRead(final int n) throws IOException {
         }
     }
 
+    /**
+     * {@inheritDoc}
+     * <p>
+     * AutoCloseInputStream does not support mark/reset no matter what.
+     * 
+     * @see org.apache.commons.io.input.ProxyInputStream#mark(int)
+     */
+    @Override
+    public synchronized void mark(int readlimit) {
+        // Behave as standard InputStream not supporting mark/reset
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p>
+     * AutoCloseInputStream does not support mark/reset no matter what.
+     * 
+     * @see org.apache.commons.io.input.ProxyInputStream#reset()
+     */
+    @Override
+    public synchronized void reset() throws IOException {
+        // Behave as standard InputStream not supporting mark/reset
+        throw new IOException("mark/reset not supported");
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p>
+     * AutoCloseInputStream does not support mark/reset no matter what.
+     * 
+     * @see org.apache.commons.io.input.ProxyInputStream#markSupported()
+     */
+    @Override
+    public boolean markSupported() {
+        // Behave as standard InputStream not supporting mark/reset
+        return false;
+    }
+
     /**
      * Ensures that the stream is closed before it gets garbage-collected.
      * As mentioned in {@link #close()}, this is a no-op if the stream has

src/test/java/org/apache/commons/io/input/AutoCloseInputStreamTest.java

@@ -16,37 +16,55 @@
  */
 package org.apache.commons.io.input;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 
+import org.apache.commons.io.serialization.MockSerializedClass;
 import org.junit.Before;
 import org.junit.Test;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
 /**
  * JUnit Test Case for {@link AutoCloseInputStream}.
  */
 public class AutoCloseInputStreamTest {
 
     private byte[] data;
 
+    private InputStream targetStream;
+
     private InputStream stream;
 
     private boolean closed;
 
+    private boolean marked;
+
+    private boolean reseted;
+
     @Before
     public void setUp() {
         data = new byte[] { 'x', 'y', 'z' };
-        stream = new AutoCloseInputStream(new ByteArrayInputStream(data) {
+        targetStream = new ByteArrayInputStream(data) {
             @Override
             public void close() {
                 closed = true;
             }
-        });
+
+            @Override
+            public void mark(int readAheadLimit) {
+                marked = true;
+            }
+
+            @Override
+            public synchronized void reset() {
+                reseted = true;
+            }
+        };
+        stream = new AutoCloseInputStream(targetStream);
         closed = false;
     }
 
@@ -100,4 +118,22 @@ public void testReadBufferOffsetLength() throws IOException {
         assertEquals("read(b, off, len)", -1, stream.read(b, 0, b.length));
     }
 
+    @Test
+    public void testMark() {
+        assertTrue(targetStream.markSupported());
+
+        // Make sure mark is disabled
+        assertFalse(stream.markSupported());
+        // Check that mark() does not fail
+        stream.mark(1);
+        assertFalse(marked);
+        // Check that reset() throw an exception
+        try {
+            stream.reset();
+        } catch (IOException expected) {
+            assertEquals("mark/reset not supported", expected.getMessage());
+            assertFalse(reseted);
+        }
+    }
+
 }