Improve tests

mgevantmakher · May 30, 2019 · 2dff623 · 2dff623
1 parent 552d568
commit 2dff623
Show file tree

Hide file tree

Showing 8 changed files with 135 additions and 27 deletions.
diff --git a/stream/src/test/java/com/annimon/stream/ExceptionalTest.java b/stream/src/test/java/com/annimon/stream/ExceptionalTest.java
@@ -281,16 +281,18 @@ public String apply(Integer value) throws Throwable {
                 .getOrThrow();
     }
 
-    @Test(expected = RuntimeException.class)
+    @Test
     public void testIfPresent() {
+        final Integer[] data = { 0 };
         Exceptional
                 .of(tenSupplier)
                 .ifPresent(new Consumer<Integer>() {
                     @Override
                     public void accept(Integer value) {
-                        throw new RuntimeException();
+                        data[0] = value;
                     }
                 });
+        assertThat(data[0], is(10));
     }
 
     @Test
@@ -325,6 +327,18 @@ public void accept(Throwable value) {
         }
     }
 
+    @Test
+    public void testIfExceptionOnNormalState() {
+        Exceptional
+                .of(tenSupplier)
+                .ifException(new Consumer<Throwable>() {
+                    @Override
+                    public void accept(Throwable value) {
+                        fail();
+                    }
+                });
+    }
+
     @Test
     public void testIfExceptionIs() {
         final int INTERRUPTED = 0;
@@ -378,6 +392,20 @@ public Integer apply(Throwable throwable) {
         assertEquals(10, value);
     }
 
+    @Test
+    public void testRecoverOnNormalState() {
+        int value = Exceptional
+                .of(tenSupplier)
+                .recover(new ThrowableFunction<Throwable, Integer, Throwable>() {
+                    @Override
+                    public Integer apply(Throwable throwable) {
+                        return 20;
+                    }
+                })
+                .get();
+        assertEquals(10, value);
+    }
+
     @Test(expected = FileNotFoundException.class)
     public void testRecoverError() throws Throwable {
         Exceptional
@@ -427,6 +455,25 @@ public Exceptional<Integer> apply(Throwable throwable) {
         assertEquals(10, value);
     }
 
+    @Test
+    public void testRecoverWithOnNormalState() {
+        int value = Exceptional
+                .of(new ThrowableSupplier<Integer, Throwable>() {
+                    @Override
+                    public Integer get() throws Throwable {
+                        return 42;
+                    }
+                })
+                .recoverWith(new Function<Throwable, Exceptional<Integer>>() {
+                    @Override
+                    public Exceptional<Integer> apply(Throwable throwable) {
+                        return Exceptional.of(tenSupplier);
+                    }
+                })
+                .get();
+        assertEquals(42, value);
+    }
+
     @Test(expected = IOException.class)
     public void testRecoverWithError() throws Throwable {
         Exceptional

diff --git a/stream/src/test/java/com/annimon/stream/IntPairTest.java b/stream/src/test/java/com/annimon/stream/IntPairTest.java
@@ -43,10 +43,11 @@ public void testEqualsTransitive() {
         assertEquals(p1, p3);
     }
 
+    @SuppressWarnings({"ConstantConditions", "SimplifiableJUnitAssertion"})
     @Test
     public void testEqualsWithNull() {
         final IntPair<String> p = new IntPair<String>(1, "first");
-        assertNotEquals(null, p);
+        assertFalse(p.equals(null));
     }
 
     @Test

diff --git a/stream/src/test/java/com/annimon/stream/ObjectsTest.java b/stream/src/test/java/com/annimon/stream/ObjectsTest.java
@@ -70,6 +70,12 @@ public void testHashRepeated() {
         assertEquals(initial, Objects.hash(value, "test", 10, true, value, null, 50));
     }
 
+    @SuppressWarnings("ConfusingArgumentToVarargsMethod")
+    @Test
+    public void testHashOnNull() {
+        assertEquals(0, Objects.hash(null));
+    }
+
     @Test
     public void testToString() {
         assertEquals("10", Objects.toString(10, ""));

diff --git a/stream/src/test/java/com/annimon/stream/OptionalBooleanTest.java b/stream/src/test/java/com/annimon/stream/OptionalBooleanTest.java
@@ -83,8 +83,9 @@ public void run() {
         });
     }
 
-    @Test(expected = RuntimeException.class)
+    @Test
     public void testIfPresentOrElseWhenValueAbsent() {
+        final boolean[] data = { false };
         OptionalBoolean.empty().ifPresentOrElse(new BooleanConsumer() {
             @Override
             public void accept(boolean value) {
@@ -93,9 +94,10 @@ public void accept(boolean value) {
         }, new Runnable() {
             @Override
             public void run() {
-                throw new RuntimeException();
+                data[0] = true;
             }
         });
+        assertTrue(data[0]);
     }
 
     @Test
@@ -162,15 +164,17 @@ public void accept(boolean value) {
                 });
     }
 
-    @Test(expected = RuntimeException.class)
+    @Test
     public void testExecuteIfAbsent() {
+        final boolean[] data = { false };
         OptionalBoolean.empty()
                 .executeIfAbsent(new Runnable() {
                     @Override
                     public void run() {
-                        throw new RuntimeException();
+                        data[0] = true;
                     }
                 });
+        assertTrue(data[0]);
     }
 
     @Test
@@ -339,6 +343,11 @@ public OptionalBoolean get() {
 
     @Test
     public void testOrElse() {
+        assertTrue(OptionalBoolean.of(true).orElse(false));
+    }
+
+    @Test
+    public void testOrElseOnEmptyOptional() {
         assertTrue(OptionalBoolean.empty().orElse(true));
         assertFalse(OptionalBoolean.empty().orElse(false));
     }
@@ -395,7 +404,6 @@ public NoSuchElementException get() {
         });
     }
 
-    @SuppressWarnings("EqualsBetweenInconvertibleTypes")
     @Test
     public void testEquals() {
         assertEquals(OptionalBoolean.empty(), OptionalBoolean.empty());
@@ -429,6 +437,7 @@ public void testHashCode() {
     @Test
     public void testToString() {
         assertEquals(OptionalBoolean.empty().toString(), "OptionalBoolean.empty");
+        assertEquals(OptionalBoolean.of(false).toString(), "OptionalBoolean[false]");
         assertEquals(OptionalBoolean.of(true).toString(), "OptionalBoolean[true]");
     }
 

diff --git a/stream/src/test/java/com/annimon/stream/OptionalDoubleTest.java b/stream/src/test/java/com/annimon/stream/OptionalDoubleTest.java
@@ -86,8 +86,9 @@ public void run() {
         });
     }
 
-    @Test(expected = RuntimeException.class)
+    @Test
     public void testIfPresentOrElseWhenValueAbsent() {
+        final Integer[] data = { 0 };
         OptionalDouble.empty().ifPresentOrElse(new DoubleConsumer() {
             @Override
             public void accept(double value) {
@@ -96,9 +97,10 @@ public void accept(double value) {
         }, new Runnable() {
             @Override
             public void run() {
-                throw new RuntimeException();
+                data[0] = 1;
             }
         });
+        assertThat(data[0], is(1));
     }
 
     @Test
@@ -165,15 +167,17 @@ public void accept(double value) {
                 });
     }
 
-    @Test(expected = RuntimeException.class)
+    @Test
     public void testExecuteIfAbsent() {
+        final Integer[] data = { 0 };
         OptionalDouble.empty()
                 .executeIfAbsent(new Runnable() {
                     @Override
                     public void run() {
-                        throw new RuntimeException();
+                       data[0] = 1;
                     }
                 });
+        assertThat(data[0], is(1));
     }
 
     @Test

diff --git a/stream/src/test/java/com/annimon/stream/OptionalIntTest.java b/stream/src/test/java/com/annimon/stream/OptionalIntTest.java
@@ -88,8 +88,9 @@ public void run() {
         });
     }
 
-    @Test(expected = RuntimeException.class)
+    @Test
     public void testIfPresentOrElseWhenValueAbsent() {
+        final Integer[] data = { 0 };
         OptionalInt.empty().ifPresentOrElse(new IntConsumer() {
             @Override
             public void accept(int value) {
@@ -98,9 +99,10 @@ public void accept(int value) {
         }, new Runnable() {
             @Override
             public void run() {
-                throw new RuntimeException();
+                data[0] = 1;
             }
         });
+        assertThat(data[0], is(1));
     }
 
     @Test
@@ -167,15 +169,17 @@ public void accept(int value) {
                 });
     }
 
-    @Test(expected = RuntimeException.class)
+    @Test
     public void testExecuteIfAbsent() {
+        final Integer[] data = { 0 };
         OptionalInt.empty()
                 .executeIfAbsent(new Runnable() {
                     @Override
                     public void run() {
-                        throw new RuntimeException();
+                        data[0] = 1;
                     }
                 });
+        assertThat(data[0], is(1));
     }
 
     @Test

diff --git a/stream/src/test/java/com/annimon/stream/OptionalLongTest.java b/stream/src/test/java/com/annimon/stream/OptionalLongTest.java
@@ -85,8 +85,9 @@ public void run() {
         });
     }
 
-    @Test(expected = RuntimeException.class)
+    @Test
     public void testIfPresentOrElseWhenValueAbsent() {
+        final Integer[] data = { 0 };
         OptionalLong.empty().ifPresentOrElse(new LongConsumer() {
             @Override
             public void accept(long value) {
@@ -95,9 +96,10 @@ public void accept(long value) {
         }, new Runnable() {
             @Override
             public void run() {
-                throw new RuntimeException();
+                data[0] = 1;
             }
         });
+        assertThat(data[0], is(1));
     }
 
     @Test
@@ -164,15 +166,17 @@ public void accept(long value) {
                 });
     }
 
-    @Test(expected = RuntimeException.class)
+    @Test
     public void testExecuteIfAbsent() {
+        final Integer[] data = { 0 };
         OptionalLong.empty()
                 .executeIfAbsent(new Runnable() {
                     @Override
                     public void run() {
-                        throw new RuntimeException();
+                        data[0] = 1;
                     }
                 });
+        assertThat(data[0], is(1));
     }
 
     @Test