Merge 2 similar test classes

Author: garydgregory

src/test/java/org/apache/commons/io/UncheckIOTest.java

@@ -20,12 +20,16 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
 
+import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.UncheckedIOException;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Supplier;
 
+import org.apache.commons.io.input.BrokenInputStream;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -34,11 +38,22 @@
  */
 public class UncheckTest {
 
+    private static final byte[] BYTES = { 'a', 'b' };
+    private static final String CAUSE_MESSAGE = "CauseMessage";
+    private static final String CUSTOM_MESSAGE = "Custom message";
+
+    private AtomicInteger atomicInt;
     private AtomicReference<String> ref1;
     private AtomicReference<String> ref2;
     private AtomicReference<String> ref3;
     private AtomicReference<String> ref4;
-    private AtomicInteger atomicInt;
+
+    private void assertUncheckedIOException(final IOException expected, final UncheckedIOException e) {
+        assertEquals(CUSTOM_MESSAGE, e.getMessage());
+        final IOException cause = e.getCause();
+        assertEquals(expected.getClass(), cause.getClass());
+        assertEquals(CAUSE_MESSAGE, cause.getMessage());
+    }
 
     @BeforeEach
     public void initEach() {
@@ -49,6 +64,20 @@ public void initEach() {
         atomicInt = new AtomicInteger();
     }
 
+    private ByteArrayInputStream newInputStream() {
+        return new ByteArrayInputStream(BYTES);
+    }
+
+    /**
+     * Tests {@link Uncheck#accept(IOConsumer, Object)}.
+     */
+    @Test
+    public void testAccept() {
+        final ByteArrayInputStream stream = newInputStream();
+        Uncheck.accept(n -> stream.skip(n), 1);
+        assertEquals('b', Uncheck.get(stream::read).intValue());
+    }
+
     @Test
     public void testAcceptIOBiConsumerOfTUTU() {
         assertThrows(UncheckedIOException.class, () -> Uncheck.accept((t, u) -> {
@@ -89,6 +118,38 @@ public void testAcceptIOTriConsumerOfTUVTUV() {
         assertEquals("new3", ref3.get());
     }
 
+    /**
+     * Tests {@link Uncheck#apply(IOFunction, Object)}.
+     */
+    @Test
+    public void testApply1() {
+        final ByteArrayInputStream stream = newInputStream();
+        assertEquals(1, Uncheck.apply(n -> stream.skip(n), 1).intValue());
+        assertEquals('b', Uncheck.get(stream::read).intValue());
+    }
+
+    /**
+     * Tests {@link Uncheck#apply(IOBiFunction, Object, Object)}.
+     */
+    @Test
+    public void testApply2() {
+        final ByteArrayInputStream stream = newInputStream();
+        final byte[] buf = new byte[BYTES.length];
+        assertEquals(1, Uncheck.apply((o, l) -> stream.read(buf, o, l), 0, 1).intValue());
+        assertEquals('a', buf[0]);
+    }
+
+    /**
+     * Tests {@link Uncheck#apply(IOTriFunction, Object, Object, Object)}.
+     */
+    @Test
+    public void testApply3() {
+        final ByteArrayInputStream stream = newInputStream();
+        final byte[] buf = new byte[BYTES.length];
+        assertEquals(1, Uncheck.apply((b, o, l) -> stream.read(b, o, l), buf, 0, 1).intValue());
+        assertEquals('a', buf[0]);
+    }
+
     @Test
     public void testApplyIOBiFunctionOfTURTU() {
         assertThrows(UncheckedIOException.class, () -> Uncheck.apply((t, u) -> {
@@ -150,8 +211,12 @@ public void testApplyIOTriFunctionOfTUVRTUV() {
         assertEquals("new3", ref3.get());
     }
 
+    /**
+     * Tests {@link Uncheck#get(IOSupplier)}.
+     */
     @Test
     public void testGet() {
+        assertEquals('a', Uncheck.get(() -> newInputStream().read()).intValue());
         assertThrows(UncheckedIOException.class, () -> Uncheck.get(() -> {
             throw new IOException();
         }));
@@ -170,8 +235,32 @@ public void testGetAsInt() {
         assertEquals(1, atomicInt.get());
     }
 
+    /**
+     * Tests {@link Uncheck#get(IOSupplier, Supplier)}.
+     */
+    @Test
+    public void testGetMessage() {
+        // No exception
+        assertEquals('a', Uncheck.get(() -> newInputStream().read()).intValue(), () -> CUSTOM_MESSAGE);
+        // Exception
+        final IOException expected = new IOException(CAUSE_MESSAGE);
+        try {
+            Uncheck.get(() -> new BrokenInputStream(expected).read(), () -> CUSTOM_MESSAGE);
+            fail();
+        } catch (final UncheckedIOException e) {
+            assertUncheckedIOException(expected, e);
+        }
+    }
+
+    /**
+     * Tests {@link Uncheck#run(IORunnable)}.
+     */
     @Test
     public void testRun() {
+        final ByteArrayInputStream stream = newInputStream();
+        Uncheck.run(() -> stream.skip(1));
+        assertEquals('b', Uncheck.get(stream::read).intValue());
+        //
         assertThrows(UncheckedIOException.class, () -> Uncheck.run(() -> {
             throw new IOException();
         }));
@@ -180,6 +269,27 @@ public void testRun() {
         assertEquals("new1", ref1.get());
     }
 
+    /**
+     * Tests {@link Uncheck#run(IORunnable, Supplier))}.
+     *
+     * @throws IOException
+     */
+    @Test
+    public void testRunMessage() throws IOException {
+        // No exception
+        final ByteArrayInputStream stream = newInputStream();
+        Uncheck.run(() -> stream.skip(1), () -> CUSTOM_MESSAGE);
+        assertEquals('b', Uncheck.get(stream::read).intValue());
+        final IOException expected = new IOException(CAUSE_MESSAGE);
+        // Exception
+        try {
+            Uncheck.run(() -> new BrokenInputStream(expected).read(), () -> CUSTOM_MESSAGE);
+            fail();
+        } catch (final UncheckedIOException e) {
+            assertUncheckedIOException(expected, e);
+        }
+    }
+
     @Test
     public void testTest() {
         assertThrows(UncheckedIOException.class, () -> Uncheck.test(t -> {