[IO-826] Add BrokenInputStream.BrokenInputStream(RuntimeException)

Make public Erase.rethrow(Throwable)

Author: garydgregory

src/changes/changes.xml

@@ -57,8 +57,10 @@ The <action> type attribute can be add,update,fix,remove.
       <action dev="ggregory" type="fix" issue="IO-781" due-to="Elliotte Rusty Harold">Make CharSequenceInputStream.available() more correct in the face of multibyte encodings #525.</action>
       <action dev="ggregory" type="fix" issue="IO-781" due-to="Elliotte Rusty Harold">Remove unreachable code in AbstractIOFileFilterTest #526.</action>
       <!-- Add -->
-      <action dev="ggregory" type="fix" issue="IO-825" due-to="dkdal, Gary Gregory">Add and use PathUtils.getFileName(Path, Function&lt;Path, R&gt;).</action>
-      <action dev="ggregory" type="fix" issue="IO-825" due-to="dkdal, Gary Gregory">Add and use PathUtils.getFileNameString().</action>
+      <action dev="ggregory" type="fix"                due-to="Gary Gregory">Add and use PathUtils.getFileName(Path, Function&lt;Path, R&gt;).</action>
+      <action dev="ggregory" type="fix"                due-to="Gary Gregory">Add and use PathUtils.getFileNameString().</action>
+      <action dev="ggregory" type="fix"                due-to="Gary Gregory">Make public Erase.rethrow(Throwable).</action>
+      <action dev="ggregory" type="fix" issue="IO-826" due-to="markslater, Gary Gregory">Add BrokenInputStream.BrokenInputStream(Throwable).</action>
     </release>
     <release version="2.15.1" date="2023-11-24" description="Java 8 is required.">
       <!-- FIX -->

src/main/java/org/apache/commons/io/function/Erase.java

@@ -20,8 +20,10 @@
 
 /**
  * Erases {@link IOException} for the compiler but still throws that exception at runtime.
+ *
+ * @since 2.16.0
  */
-final class Erase {
+public final class Erase {
 
     /**
      * Delegates to the given {@link IOBiConsumer} but erases its {@link IOException} for the compiler, while still throwing
@@ -144,7 +146,7 @@ static <T> T get(final IOSupplier<T> supplier) {
      * @throws T Always thrown.
      */
     @SuppressWarnings("unchecked")
-    static <T extends Throwable> RuntimeException rethrow(final Throwable throwable) throws T {
+    public static <T extends Throwable> RuntimeException rethrow(final Throwable throwable) throws T {
         throw (T) throwable;
     }
 

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

@@ -20,6 +20,8 @@
 import java.io.InputStream;
 import java.util.function.Supplier;
 
+import org.apache.commons.io.function.Erase;
+
 /**
  * Always throws an {@link IOException} from all the {@link InputStream} methods where the exception is declared.
  * <p>
@@ -40,7 +42,7 @@ public class BrokenInputStream extends InputStream {
     /**
      * A supplier for the exception that is thrown by all methods of this class.
      */
-    private final Supplier<IOException> exceptionSupplier;
+    private final Supplier<Throwable> exceptionSupplier;
 
     /**
      * Constructs a new stream that always throws an {@link IOException}.
@@ -53,18 +55,30 @@ public BrokenInputStream() {
      * Constructs a new stream that always throws the given exception.
      *
      * @param exception the exception to be thrown.
+     * @deprecated Use {@link #BrokenInputStream(Throwable)}.
      */
+    @Deprecated
     public BrokenInputStream(final IOException exception) {
         this(() -> exception);
     }
 
+    /**
+     * Constructs a new stream that always throws the given exception.
+     *
+     * @param exception the exception to be thrown.
+     * @since 2.16.0
+     */
+    public BrokenInputStream(final Throwable exception) {
+        this(() -> exception);
+    }
+
     /**
      * Constructs a new stream that always throws an {@link IOException}.
      *
-     * @param exceptionSupplier a supplier for the exception to be thrown.
+     * @param exceptionSupplier a supplier for the IOException or RuntimeException to be thrown.
      * @since 2.12.0
      */
-    public BrokenInputStream(final Supplier<IOException> exceptionSupplier) {
+    public BrokenInputStream(final Supplier<Throwable> exceptionSupplier) {
         this.exceptionSupplier = exceptionSupplier;
     }
 
@@ -76,7 +90,7 @@ public BrokenInputStream(final Supplier<IOException> exceptionSupplier) {
      */
     @Override
     public int available() throws IOException {
-        throw exceptionSupplier.get();
+        throw rethrow();
     }
 
     /**
@@ -86,7 +100,7 @@ public int available() throws IOException {
      */
     @Override
     public void close() throws IOException {
-        throw exceptionSupplier.get();
+        throw rethrow();
     }
 
     /**
@@ -97,7 +111,7 @@ public void close() throws IOException {
      */
     @Override
     public int read() throws IOException {
-        throw exceptionSupplier.get();
+        throw rethrow();
     }
 
     /**
@@ -107,7 +121,16 @@ public int read() throws IOException {
      */
     @Override
     public synchronized void reset() throws IOException {
-        throw exceptionSupplier.get();
+        throw rethrow();
+    }
+
+    /**
+     * Throws the configured exception from its supplier.
+     *
+     * @return Throws the configured exception from its supplier.
+     */
+    private RuntimeException rethrow() {
+        return Erase.rethrow(exceptionSupplier.get());
     }
 
     /**
@@ -119,7 +142,7 @@ public synchronized void reset() throws IOException {
      */
     @Override
     public long skip(final long n) throws IOException {
-        throw exceptionSupplier.get();
+        throw rethrow();
     }
 
 }

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

@@ -19,56 +19,99 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
+import java.nio.file.FileSystemNotFoundException;
+import java.util.stream.Stream;
 
-import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
 
 /**
  * Tests {@link BrokenInputStream}.
  */
 public class BrokenInputStreamTest {
 
-    private IOException exception;
+    static final class CustomeException extends Exception {
 
-    private InputStream stream;
+        private static final long serialVersionUID = 1L;
 
-    @BeforeEach
-    public void setUp() {
-        exception = new IOException("test exception");
-        stream = new BrokenInputStream(exception);
     }
 
-    @Test
-    public void testAvailable() {
-        assertEquals(exception, assertThrows(IOException.class, () -> stream.available()));
+    static Stream<Class<? extends Throwable>> parameters() {
+        // @formatter:off
+        return Stream.of(
+            IOException.class,
+            FileNotFoundException.class,
+            FileSystemNotFoundException.class,
+            RuntimeException.class,
+            IllegalArgumentException.class,
+            IllegalStateException.class,
+            Error.class,
+            ExceptionInInitializerError.class,
+            CustomeException.class
+        );
+        // @formatter:on
     }
 
-    @Test
-    public void testClose() {
-        assertEquals(exception, assertThrows(IOException.class, () -> stream.close()));
+    private BrokenInputStream createBrokenInputStream(final Throwable exception) {
+        if (exception instanceof IOException) {
+            return new BrokenInputStream((IOException) exception);
+        }
+        return new BrokenInputStream(exception);
     }
 
-    @Test
-    public void testRead() {
-        assertEquals(exception, assertThrows(IOException.class, () -> stream.read()));
-        assertEquals(exception, assertThrows(IOException.class, () -> stream.read(new byte[1])));
-        assertEquals(exception, assertThrows(IOException.class, () -> stream.read(new byte[1], 0, 1)));
+    @ParameterizedTest
+    @MethodSource("parameters")
+    public void testAvailable(final Class<Exception> clazz) throws Exception {
+        final Throwable exception = clazz.newInstance();
+        @SuppressWarnings("resource")
+        final BrokenInputStream stream = createBrokenInputStream(exception);
+        assertEquals(exception, assertThrows(exception.getClass(), () -> stream.available()));
     }
 
-    @Test
-    public void testReset() {
-        assertEquals(exception, assertThrows(IOException.class, () -> stream.reset()));
+    @ParameterizedTest
+    @MethodSource("parameters")
+    public void testClose(final Class<Exception> clazz) throws Exception {
+        final Throwable exception = clazz.newInstance();
+        @SuppressWarnings("resource")
+        final BrokenInputStream stream = createBrokenInputStream(exception);
+        assertEquals(exception, assertThrows(exception.getClass(), () -> stream.close()));
     }
 
-    @Test
-    public void testSkip() {
-        assertEquals(exception, assertThrows(IOException.class, () -> stream.skip(1)));
+    @ParameterizedTest
+    @MethodSource("parameters")
+    public void testRead(final Class<Exception> clazz) throws Exception {
+        final Throwable exception = clazz.newInstance();
+        @SuppressWarnings("resource")
+        final BrokenInputStream stream = createBrokenInputStream(exception);
+        assertEquals(exception, assertThrows(exception.getClass(), () -> stream.read()));
+        assertEquals(exception, assertThrows(exception.getClass(), () -> stream.read(new byte[1])));
+        assertEquals(exception, assertThrows(exception.getClass(), () -> stream.read(new byte[1], 0, 1)));
+    }
+
+    @ParameterizedTest
+    @MethodSource("parameters")
+    public void testReset(final Class<Exception> clazz) throws Exception {
+        final Throwable exception = clazz.newInstance();
+        @SuppressWarnings("resource")
+        final BrokenInputStream stream = createBrokenInputStream(exception);
+        assertEquals(exception, assertThrows(exception.getClass(), () -> stream.reset()));
+    }
+
+    @ParameterizedTest
+    @MethodSource("parameters")
+    public void testSkip(final Class<Exception> clazz) throws Exception {
+        final Throwable exception = clazz.newInstance();
+        @SuppressWarnings("resource")
+        final BrokenInputStream stream = createBrokenInputStream(exception);
+        assertEquals(exception, assertThrows(exception.getClass(), () -> stream.skip(1)));
     }
 
     @Test
-    public void testTryWithResources() {
+    public void testTryWithResources() throws Exception {
         final IOException thrown = assertThrows(IOException.class, () -> {
             try (InputStream newStream = new BrokenInputStream()) {
                 newStream.read();