diff --git a/src/test/java/com/github/underscore/ArraysTest.java b/src/test/java/com/github/underscore/ArraysTest.java
index fa231258..33e335fb 100644
--- a/src/test/java/com/github/underscore/ArraysTest.java
+++ b/src/test/java/com/github/underscore/ArraysTest.java
@@ -318,7 +318,7 @@ void chunkFill() {
     @Test
     void cycle() {
         assertEquals("[]", Underscore.cycle(Underscore.range(5), 0).toString());
-        assertEquals("[]", Underscore.cycle(new ArrayList<Object>(), 5).toString());
+        assertEquals("[]", Underscore.cycle(new ArrayList<>(), 5).toString());
         assertEquals("[4, 3, 2, 1, 0]", Underscore.cycle(Underscore.range(5), -1).toString());
         assertEquals(
                 "[0, 1, 2, 0, 1, 2, 0, 1, 2]", Underscore.cycle(Underscore.range(3), 3).toString());
@@ -370,8 +370,8 @@ void interpose() {
         assertEquals(
                 "[0, 500, 1, 500, 2, 500, 3]",
                 Underscore.interpose(Underscore.range(4), 500).toString());
-        assertEquals("[]", Underscore.interpose(new ArrayList<Integer>(), 500).toString());
-        assertEquals("[]", Underscore.interpose(new ArrayList<Object>(), null).toString());
+        assertEquals("[]", Underscore.interpose(new ArrayList<>(), 500).toString());
+        assertEquals("[]", Underscore.interpose(new ArrayList<>(), null).toString());
         assertEquals(
                 "[0, 1, 2, 3]",
                 Underscore.interpose(Underscore.newArrayList(Underscore.range(4)), null)
@@ -384,7 +384,7 @@ void interpose() {
         assertEquals("[a, b]", new Underscore<>(singletonList("a, b")).interpose(null).toString());
         assertEquals("[a]", Underscore.chain(singletonList("a")).interpose("interpose").toString());
         assertEquals(
-                "[]", Underscore.chain(new ArrayList<Object>()).interpose("interpose").toString());
+                "[]", Underscore.chain(new ArrayList<>()).interpose("interpose").toString());
         assertEquals(
                 "[a, b, c]", Underscore.chain(asList("a", "b", "c")).interpose(null).toString());
         assertEquals(
@@ -771,7 +771,7 @@ public String toString() {
             }
         }
         final int result =
-                Underscore.<Person>sortedIndex(
+                Underscore.sortedIndex(
                         asList(
                                 new Person("moe", 40),
                                 new Person("moe", 50),
@@ -780,7 +780,7 @@ public String toString() {
                         "age");
         assertEquals(1, result);
         final int result2 =
-                Underscore.<Person>sortedIndex(
+                Underscore.sortedIndex(
                         asList(
                                 new Person("moe", 40),
                                 new Person("moe", 50),
@@ -789,7 +789,7 @@ public String toString() {
                         "age");
         assertEquals(-1, result2);
         final int resultArray =
-                Underscore.<Person>sortedIndex(
+                Underscore.sortedIndex(
                         new Person[] {
                             new Person("moe", 40), new Person("moe", 50), new Person("curly", 60)
                         },
diff --git a/src/test/java/com/github/underscore/MathTest.java b/src/test/java/com/github/underscore/MathTest.java
index 65a84870..b455b66e 100644
--- a/src/test/java/com/github/underscore/MathTest.java
+++ b/src/test/java/com/github/underscore/MathTest.java
@@ -62,7 +62,7 @@ void average2() {
         assertEquals("2.0", result2.toString());
         final Double result3 = U.average(asList((float) 1, (float) 2, (float) 3));
         assertEquals("2.0", result3.toString());
-        final Double result4 = U.average(asList((int) 1, (int) 2, (int) 3));
+        final Double result4 = U.average(asList(1, 2, 3));
         assertEquals("2.0", result4.toString());
         final Double result5 = U.average(asList((long) 1, (long) 2, (long) 3));
         assertEquals("2.0", result5.toString());
@@ -88,13 +88,13 @@ void average2() {
 
     @Test
     void average3() {
-        final Double result10 = U.average(asList(1, (Integer) null));
+        final Double result10 = U.average(asList(1, null));
         assertEquals("0.5", result10.toString());
-        final Double result11 = U.average(asList((double) 0.2, (double) 0.1, Math.PI));
+        final Double result11 = U.average(asList(0.2, 0.1, Math.PI));
         assertEquals(Double.valueOf((0.2 + 0.1 + Math.PI) / 3).toString(), result11.toString());
-        final Double result12 = U.average(asList((double) 0, (double) 14, (double) 0.2));
+        final Double result12 = U.average(asList((double) 0, (double) 14, 0.2));
         assertEquals(Double.valueOf((0 + 14 + 0.2) / 3), result12);
-        final Double result13 = U.average(asList((int) -1, (int) -2, (int) -3));
+        final Double result13 = U.average(asList(-1, -2, -3));
         assertEquals("-2.0", result13.toString());
         final Double result14 = U.average(new Integer[] {1, 2, 3});
         assertEquals("2.0", result14.toString());
@@ -174,7 +174,7 @@ void average6() {
         assertEquals("3.0", result41.toString());
         final Double result42 = U.average(Long.valueOf(2), Long.valueOf(4));
         assertEquals("3.0", result42.toString());
-        final Double result43 = U.average(new Integer[] {(Integer) null});
+        final Double result43 = U.average(new Integer[] {null});
         assertNull(result43);
     }
 
@@ -200,7 +200,7 @@ void sum() {
         assertEquals("6.0", result2.toString());
         final Float result3 = U.sum(asList((float) 1, (float) 2, (float) 3));
         assertEquals("6.0", result3.toString());
-        final Integer result4 = U.sum(asList((int) 1, (int) 2, (int) 3));
+        final Integer result4 = U.sum(asList(1, 2, 3));
         assertEquals("6", result4.toString());
         final Long result5 = U.sum(asList((long) 1, (long) 2, (long) 3));
         assertEquals("6", result5.toString());
@@ -212,18 +212,18 @@ void sum() {
         final BigInteger result8 =
                 U.sum(asList(BigInteger.valueOf(1), BigInteger.valueOf(2), BigInteger.valueOf(3)));
         assertEquals("6", result8.toString());
-        final Integer result9 = U.sum(Collections.singletonList((Integer) null));
+        final Integer result9 = U.sum(Collections.singletonList(null));
         assertNull(result9);
-        final Integer result10 = U.sum(asList(1, (Integer) null));
+        final Integer result10 = U.sum(asList(1, null));
         assertEquals("1", result10.toString());
-        final Double result11 = U.sum(asList((double) 0.2, (double) 0.1, Math.PI));
+        final Double result11 = U.sum(asList(0.2, 0.1, Math.PI));
         assertEquals(Double.valueOf(0.2 + 0.1 + Math.PI).toString(), result11.toString());
-        final Double result12 = U.sum(asList((double) 0, (double) 14, (double) 0.2));
+        final Double result12 = U.sum(asList((double) 0, (double) 14, 0.2));
         assertEquals("14.2", result12.toString());
-        final Integer result13 = U.sum(asList((int) -1, (int) -2, (int) -3));
+        final Integer result13 = U.sum(asList(-1, -2, -3));
         assertEquals("-6", result13.toString());
         final Integer resultChain =
-                (Integer) U.chain(asList((int) 1, (int) 2, (int) 3)).sum().item();
+                (Integer) U.chain(asList(1, 2, 3)).sum().item();
         assertEquals("6", resultChain.toString());
         final Integer result14 = U.sum(new Integer[] {1, 2, 3});
         assertEquals("6", result14.toString());
@@ -250,9 +250,9 @@ void sum() {
         final Integer result21 = U.sum(new Integer[] {1, 2, null});
         assertEquals("3", result21.toString());
         final Integer resultChainFunc =
-                (Integer) U.chain(asList((int) 1, (int) 2, (int) 3)).sum(item -> item * 2).item();
+                U.chain(asList(1, 2, 3)).sum(item -> item * 2).item();
         assertEquals("12", resultChainFunc.toString());
-        final Number resultObj = new U(asList((int) 1, (int) 2, (int) 3)).sum();
+        final Number resultObj = new U(asList(1, 2, 3)).sum();
         assertEquals("6", resultObj.toString());
         final Number resultObjFunc =
                 new U(asList((byte) 1, (byte) 2, (byte) 3))
@@ -296,7 +296,7 @@ public double doubleValue() {
     void subtract() {
         assertEquals("-1", U.subtract((byte) 1, (byte) 2).toString());
         assertEquals("-1", U.subtract((short) 1, (short) 2).toString());
-        assertEquals("-1", U.subtract((int) 1, (int) 2).toString());
+        assertEquals("-1", U.subtract(1, 2).toString());
         assertEquals("-1", U.subtract((long) 1, (long) 2).toString());
         assertEquals("-1.0", U.subtract((float) 1, (float) 2).toString());
         assertEquals("-1.0", U.subtract((double) 1, (double) 2).toString());
@@ -308,9 +308,9 @@ void subtract() {
         assertEquals("-1.0", U.subtract(1d, 2d).toString());
         assertEquals("-1", U.subtract(BigDecimal.valueOf(1), BigDecimal.valueOf(2)).toString());
         assertEquals("-1", U.subtract(BigInteger.valueOf(1), BigInteger.valueOf(2)).toString());
-        assertEquals("-1", U.subtract((Number) 1, (Number) 2).toString());
-        assertEquals("-4", U.subtract((int) 1, (int) 2, (int) 3).toString());
-        assertEquals("1", U.subtract((int) 1).toString());
+        assertEquals("-1", U.subtract(1, (Number) 2).toString());
+        assertEquals("-4", U.subtract(1, 2, 3).toString());
+        assertEquals("1", U.subtract(1).toString());
         assertEquals((Object) null, U.subtract());
     }
 
@@ -346,12 +346,12 @@ public double doubleValue() {
     @SuppressWarnings("unchecked")
     @Test
     void mean() {
-        final Double result = U.mean(asList((double) 0, (double) 0.5, (double) 1));
+        final Double result = U.mean(asList((double) 0, 0.5, (double) 1));
         assertEquals("0.5", result.toString());
-        final Double resultObj = new U(asList((double) 0, (double) 0.5, (double) 1)).mean();
+        final Double resultObj = new U(asList((double) 0, 0.5, (double) 1)).mean();
         assertEquals("0.5", resultObj.toString());
         final Double resultChain =
-                (Double) U.chain(asList((double) 0, (double) 0.5, (double) 1)).mean().item();
+                U.chain(asList((double) 0, 0.5, (double) 1)).mean().item();
         assertEquals("0.5", resultChain.toString());
         final Double result2 = U.mean(asList((long) 0, (long) 1, (long) 2));
         assertEquals("1.0", result2.toString());
@@ -372,20 +372,20 @@ void mean() {
     @SuppressWarnings("unchecked")
     @Test
     void median() {
-        final Double result = U.median(asList((int) 0, (int) 0, (int) 0, (int) 0, (int) 5));
+        final Double result = U.median(asList(0, 0, 0, 0, 5));
         assertEquals("0.0", result.toString());
         final Double resultObj =
-                new U<>(asList((int) 0, (int) 0, (int) 0, (int) 0, (int) 5)).median();
+                new U<>(asList(0, 0, 0, 0, 5)).median();
         assertEquals("0.0", resultObj.toString());
         final Double resultChain =
-                U.chain(asList((int) 0, (int) 0, (int) 0, (int) 0, (int) 5)).median().item();
+                U.chain(asList(0, 0, 0, 0, 5)).median().item();
         assertEquals("0.0", resultChain.toString());
-        final Double result2 = U.median(asList((int) 0, (int) 0, (int) 1, (int) 2, (int) 5));
+        final Double result2 = U.median(asList(0, 0, 1, 2, 5));
         assertEquals("1.0", result2.toString());
-        final Double result3 = U.median(asList((int) 0, (int) 0, (int) 1, (int) 2));
+        final Double result3 = U.median(asList(0, 0, 1, 2));
         assertEquals("0.5", result3.toString());
         final Double result4 =
-                U.median(asList((int) 0, (int) 0, (int) 1, (int) 2, (int) 3, (int) 4));
+                U.median(asList(0, 0, 1, 2, 3, 4));
         assertEquals("1.5", result4.toString());
     }
 
diff --git a/src/test/java/com/github/underscore/StringTest.java b/src/test/java/com/github/underscore/StringTest.java
index d10acd9f..a9401261 100644
--- a/src/test/java/com/github/underscore/StringTest.java
+++ b/src/test/java/com/github/underscore/StringTest.java
@@ -85,7 +85,7 @@ void camelCase() {
     @Test
     void explode() {
         assertEquals(asList("a", "b", "c"), U.explode("abc"));
-        assertEquals(new ArrayList<Object>(), U.explode(null));
+        assertEquals(new ArrayList<>(), U.explode(null));
     }
 
     /*
@@ -189,7 +189,7 @@ void endsWith() {
         assertTrue(new U<String>("abc").endsWith("b", 2));
         assertTrue(U.chain("abc").endsWith("b", 2).item());
         assertFalse(U.endsWith("abc", "c", -4));
-        assertFalse(U.endsWith((String) null, (String) null));
+        assertFalse(U.endsWith(null, (String) null));
         assertFalse(U.endsWith("1", (String) null));
         assertFalse(U.endsWith(null, "1"));
         assertTrue(U.endsWith("1", "1"));
@@ -274,7 +274,7 @@ void startsWith() {
         assertTrue(new U<String>("abc").startsWith("b", 1));
         assertTrue(U.chain("abc").startsWith("b", 1).item());
         assertFalse(U.startsWith("abc", "c", -4));
-        assertFalse(U.startsWith((String) null, (String) null));
+        assertFalse(U.startsWith(null, (String) null));
         assertFalse(U.startsWith("1", (String) null));
         assertFalse(U.startsWith(null, "1"));
         assertTrue(U.startsWith("1", "1"));
@@ -1041,7 +1041,7 @@ void testDecodeParseErr14() {
     void testXmlArray() {
         XmlStringBuilder builder = new XmlStringBuilder();
         Xml.XmlArray.writeXml(
-                null, null, builder, false, Collections.<String>emptySet(), false, ARRAY_TRUE);
+                null, null, builder, false, Collections.emptySet(), false, ARRAY_TRUE);
         assertEquals(
                 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<root>\nnull\n</root>",
                 builder.toString());
@@ -1049,13 +1049,13 @@ void testXmlArray() {
         Xml.XmlArray.writeXml(
                 new ArrayList<String>() {
                     {
-                        add((String) null);
+                        add(null);
                     }
                 },
                 null,
                 builder,
                 false,
-                Collections.<String>emptySet(),
+                Collections.emptySet(),
                 false,
                 ARRAY_TRUE);
         assertEquals(
@@ -1066,13 +1066,13 @@ void testXmlArray() {
         Xml.XmlArray.writeXml(
                 new ArrayList<String>() {
                     {
-                        add((String) null);
+                        add(null);
                     }
                 },
                 "name",
                 builder,
                 false,
-                Collections.<String>emptySet(),
+                Collections.emptySet(),
                 false,
                 ARRAY_TRUE);
         assertEquals(
@@ -1470,7 +1470,7 @@ void testXmlObjectArrayToString() {
 
         builder = new XmlStringBuilder();
         Xml.XmlArray.writeXml(
-                new Object[0], null, builder, false, Collections.<String>emptySet(), ARRAY_TRUE);
+                new Object[0], null, builder, false, Collections.emptySet(), ARRAY_TRUE);
         assertEquals(
                 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<root>\n  <element></element>\n</root>",
                 builder.toString());
@@ -1481,7 +1481,7 @@ void testXmlObjectArrayToString() {
                 null,
                 builder,
                 false,
-                Collections.<String>emptySet(),
+                Collections.emptySet(),
                 ARRAY_TRUE);
         assertEquals(
                 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<root>\n  <element>Hello</element>\n</root>",
@@ -1493,7 +1493,7 @@ void testXmlObjectArrayToString() {
                 null,
                 builder,
                 false,
-                Collections.<String>emptySet(),
+                Collections.emptySet(),
                 ARRAY_TRUE);
         assertEquals(
                 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<root>\n  <element>Hello</element>\n"
@@ -3563,7 +3563,7 @@ void fromJsonStackoverflowObject() throws IOException {
         try {
             U.fromJsonMap(stringJson);
         } catch (Throwable throwable) {
-            assertTrue(throwable instanceof StackOverflowError);
+            assertInstanceOf(StackOverflowError.class, throwable);
         }
     }
 
@@ -3733,7 +3733,7 @@ void main() {
         U.main(new String[] {});
         new U<>(new ArrayList<>());
         new U<String>("");
-        new U<>(Collections.<Object>emptyList()).chain();
+        new U<>(Collections.emptyList()).chain();
         U.chain(new ArrayList<String>());
         U.chain(new HashSet<String>());
         assertNull(U.chain(new String[] {}).item());
diff --git a/src/test/java/com/github/underscore/UnderscoreTest.java b/src/test/java/com/github/underscore/UnderscoreTest.java
index f018e03c..7b1821b0 100644
--- a/src/test/java/com/github/underscore/UnderscoreTest.java
+++ b/src/test/java/com/github/underscore/UnderscoreTest.java
@@ -410,7 +410,7 @@ void get() {
     */
     @Test
     void set() {
-        Map.Entry<Integer, List<Integer>> result = Underscore.<Integer>set(asList(1, 2, 3), 1, 100);
+        Map.Entry<Integer, List<Integer>> result = Underscore.set(asList(1, 2, 3), 1, 100);
         assertEquals(2, result.getKey().intValue());
         assertEquals(100, Underscore.<Integer>get(result.getValue(), 1).intValue());
         Map.Entry<Integer, List<Integer>> result2 = new Underscore<>(asList(1, 2, 3)).set(2, 200);
@@ -473,7 +473,7 @@ void findLastWithCustomIterable() {
         final int[] array = new int[] {1, 2, 3, 4, 5, 6};
         Iterable<Integer> iterable =
                 () ->
-                        new Iterator<Integer>() {
+                        new Iterator<>() {
                             private int index;
 
                             public boolean hasNext() {
@@ -496,7 +496,7 @@ public void remove() {
     @Test
     void iterate() {
         Iterable<long[]> iterable =
-                Underscore.<long[]>iterate(
+                Underscore.iterate(
                         new long[] {1, 1}, arg -> new long[] {arg[1], arg[0] + arg[1]});
         iterable.iterator().remove();
         assertTrue(iterable.iterator().hasNext());
@@ -507,13 +507,13 @@ void iterate() {
     @Test
     void iterateChain() {
         Iterable<long[]> iterable =
-                Underscore.<long[]>iterate(
+                Underscore.iterate(
                         new long[] {1, 1}, arg -> new long[] {arg[1], arg[0] + arg[1]});
         assertEquals(1L, Underscore.chain(iterable, 5).first().item()[0]);
         Underscore.of(iterable, 5);
         class MyIterable<T> implements Iterable<T> {
             public Iterator<T> iterator() {
-                return new Iterator<T>() {
+                return new Iterator<>() {
                     @Override
                     public boolean hasNext() {
                         return false;
@@ -558,7 +558,7 @@ void optional() {
         assertEquals("Optional[1]", Optional.ofNullable(1).toString());
         assertEquals("1", Optional.<Integer>empty().orElse(1).toString());
         assertEquals("1", Optional.of(1).orElse(2).toString());
-        assertEquals(null, Optional.empty().orElse(null));
+        assertNull(Optional.empty().orElse(null));
         assertEquals("1", Optional.of(1).orElse(null).toString());
         assertFalse(Optional.<Integer>empty().map(arg -> "" + arg).isPresent());
         assertTrue(Optional.<Integer>empty().map(arg -> "" + arg).isEmpty());
@@ -774,23 +774,22 @@ void jobtest() {
             "They all want you to play I watch the birds of prey"
         };
         List<Map<String, Object>> result =
-                (List<Map<String, Object>>)
-                        Underscore.chain(asList(strings))
-                                .map(
-                                        item -> {
-                                            Map<String, Object> resultItem = new LinkedHashMap<>();
-                                            resultItem.put("string", item);
-                                            resultItem.put(
-                                                    "longestWord",
-                                                    Underscore.chain(asList(item.split("\\s+")))
-                                                            .map(String::length)
-                                                            .max()
-                                                            .item());
-                                            return resultItem;
-                                        })
-                                .sortBy(item -> -((Integer) item.get("longestWord")))
-                                .limit(5)
-                                .value();
+                Underscore.chain(asList(strings))
+                        .map(
+                                item -> {
+                                    Map<String, Object> resultItem = new LinkedHashMap<>();
+                                    resultItem.put("string", item);
+                                    resultItem.put(
+                                            "longestWord",
+                                            Underscore.chain(asList(item.split("\\s+")))
+                                                    .map(String::length)
+                                                    .max()
+                                                    .item());
+                                    return resultItem;
+                                })
+                        .sortBy(item -> -((Integer) item.get("longestWord")))
+                        .limit(5)
+                        .value();
         assertEquals(
                 "[{string=Aliens are watching up in the sky, longestWord=8}, "
                         + "{string=Sound boy proceed to blast into the galaxy, longestWord=7}, "
diff --git a/src/test/java/com/github/underscore/UtilityTest.java b/src/test/java/com/github/underscore/UtilityTest.java
index 75a93b8d..664dad80 100644
--- a/src/test/java/com/github/underscore/UtilityTest.java
+++ b/src/test/java/com/github/underscore/UtilityTest.java
@@ -26,6 +26,7 @@
 import static java.util.Arrays.asList;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.ArrayList;
@@ -474,9 +475,7 @@ void result() {
         assertEquals(
                 "result1",
                 Underscore.result(asList("result1", "result2"), item -> item.equals("result1")));
-        assertEquals(
-                null,
-                Underscore.result(asList("result1", "result2"), item -> item.equals("result3")));
+        assertNull(Underscore.result(asList("result1", "result2"), item -> item.equals("result3")));
     }
 
     @Test
diff --git a/src/test/java/com/github/underscore/XmlBuilderTest.java b/src/test/java/com/github/underscore/XmlBuilderTest.java
index 07ac2872..36c0b291 100644
--- a/src/test/java/com/github/underscore/XmlBuilderTest.java
+++ b/src/test/java/com/github/underscore/XmlBuilderTest.java
@@ -25,6 +25,7 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
@@ -115,7 +116,7 @@ void parse() {
     @Test
     void getDocument() {
         XmlBuilder xmlBuilder = new XmlBuilder(null);
-        assertTrue(xmlBuilder.getDocument() instanceof Document);
+        assertInstanceOf(Document.class, xmlBuilder.getDocument());
     }
 
     @Test