Add a bunch of test in order to increase the coverage. (#904)

9 files changed, 124 insertions, 4 deletions

diff --git a/src/test/java/org/apache/commons/lang3/ArchUtilsTest.java b/src/test/java/org/apache/commons/lang3/ArchUtilsTest.java
index 397158199..fbe80f4dc 100644
--- a/src/test/java/org/apache/commons/lang3/ArchUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/ArchUtilsTest.java
@@ -113,6 +113,10 @@ public class ArchUtilsTest extends AbstractLangTest {
     public void testGetProcessor() {
         assertNotNull(ArchUtils.getProcessor(X86));
         assertNull(ArchUtils.getProcessor("NA"));
+
+        final Processor processor = ArchUtils.getProcessor();
+        assertTrue(processor.isX86());
+
     }
 
     @Test
diff --git a/src/test/java/org/apache/commons/lang3/ClassUtilsTest.java b/src/test/java/org/apache/commons/lang3/ClassUtilsTest.java
index 6131e8601..4534206f7 100644
--- a/src/test/java/org/apache/commons/lang3/ClassUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/ClassUtilsTest.java
@@ -52,6 +52,8 @@ import org.junit.jupiter.api.Test;
 @SuppressWarnings("boxing") // JUnit4 does not support primitive equality testing apart from long
 public class ClassUtilsTest extends AbstractLangTest {
 
+    private static final String OBJECT_CANONICAL_NAME = "java.lang.Object";
+
     private static class CX implements IB, IA, IE {
         // empty
     }
@@ -121,7 +123,7 @@ public class ClassUtilsTest extends AbstractLangTest {
         assertEquals(3, result.size());
         assertEquals("java.lang.String", result.get(0));
         assertNull(result.get(1));
-        assertEquals("java.lang.Object", result.get(2));
+        assertEquals(OBJECT_CANONICAL_NAME, result.get(2));
 
         @SuppressWarnings("unchecked") // test what happens when non-generic code adds wrong type of element
         final List<Object> olist = (List<Object>) (List<?>) list;
@@ -138,7 +140,7 @@ public class ClassUtilsTest extends AbstractLangTest {
 
         list.add("java.lang.String");
         list.add("java.lang.xxx");
-        list.add("java.lang.Object");
+        list.add(OBJECT_CANONICAL_NAME);
         result = ClassUtils.convertClassNamesToClasses(list);
         assertEquals(3, result.size());
         assertEquals(String.class, result.get(0));
@@ -323,6 +325,13 @@ public class ClassUtilsTest extends AbstractLangTest {
         }.getClass(), "X"));
         assertEquals("X", ClassUtils.getCanonicalName(Named.class, "X"));
         assertEquals("org.apache.commons.lang3.ClassUtilsTest.Inner", ClassUtils.getCanonicalName(Inner.class, "X"));
+        assertEquals("X", ClassUtils.getCanonicalName((Object) null, "X"));
+        assertEquals(OBJECT_CANONICAL_NAME, ClassUtils.getCanonicalName(new Object()));
+    }
+
+    @Test
+    public void test_getClass() {
+       // assertEquals("org.apache.commons.lang3.ClassUtils", ClassUtils.getName(ClassLoader.class, "@"));
     }
 
     @Test
@@ -368,6 +377,7 @@ public class ClassUtilsTest extends AbstractLangTest {
         }.getClass()));
         assertEquals("org.apache.commons.lang3.ClassUtilsTest$3Named", ClassUtils.getName(Named.class));
         assertEquals("org.apache.commons.lang3.ClassUtilsTest$Inner", ClassUtils.getName(Inner.class));
+        assertEquals(OBJECT_CANONICAL_NAME, ClassUtils.getName(new Object()));
     }
 
     @Test
@@ -405,6 +415,7 @@ public class ClassUtilsTest extends AbstractLangTest {
         }.getClass()));
         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(Named.class));
         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(Inner.class));
+        assertEquals(StringUtils.EMPTY, ClassUtils.getPackageCanonicalName((Class<?>) null));
     }
 
     @Test
@@ -513,6 +524,7 @@ public class ClassUtilsTest extends AbstractLangTest {
         // WARNING: this is fragile, implementation may change, naming is not guaranteed
         assertEquals("ClassUtilsTest.8Named", ClassUtils.getShortCanonicalName(Named.class));
         assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortCanonicalName(Inner.class));
+        assertEquals(StringUtils.EMPTY, ClassUtils.getShortCanonicalName((Class<?>) null));
     }
 
     @Test
diff --git a/src/test/java/org/apache/commons/lang3/NotImplementedExceptionTest.java b/src/test/java/org/apache/commons/lang3/NotImplementedExceptionTest.java
index 84f0485a5..25852a3d5 100644
--- a/src/test/java/org/apache/commons/lang3/NotImplementedExceptionTest.java
+++ b/src/test/java/org/apache/commons/lang3/NotImplementedExceptionTest.java
@@ -18,6 +18,7 @@ package org.apache.commons.lang3;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 import org.junit.jupiter.api.Test;
 
@@ -44,6 +45,8 @@ public class NotImplementedExceptionTest extends AbstractLangTest {
         assertCorrect("Issue in (Throwable, String)", nie, nested.toString(), nested, code);
         nie = new NotImplementedException(message, nested, code);
         assertCorrect("Issue in (String, Throwable, String)", nie, message, nested, code);
+
+        assertNull(new NotImplementedException().getCode());
     }
 
     private void assertCorrect(final String assertMessage, final NotImplementedException nie, final String message, final Throwable nested, final String code) {
diff --git a/src/test/java/org/apache/commons/lang3/RangeTest.java b/src/test/java/org/apache/commons/lang3/RangeTest.java
index 789045428..628192a5a 100644
--- a/src/test/java/org/apache/commons/lang3/RangeTest.java
+++ b/src/test/java/org/apache/commons/lang3/RangeTest.java
@@ -103,6 +103,10 @@ public class RangeTest extends AbstractLangTest {
         assertTrue(rbstr.contains("i"), "should contain i");
         assertFalse(rbstr.contains("houses"), "should not contain houses");
         assertFalse(rbstr.contains(""), "should not contain ''");
+
+        assertThrows(
+                IllegalArgumentException.class,
+                () -> Range.between(null, null, lengthComp));
     }
 
     @SuppressWarnings({"rawtypes", "unchecked"})
diff --git a/src/test/java/org/apache/commons/lang3/ValidateTest.java b/src/test/java/org/apache/commons/lang3/ValidateTest.java
index 44fce1ab5..4ce3b4e84 100644
--- a/src/test/java/org/apache/commons/lang3/ValidateTest.java
+++ b/src/test/java/org/apache/commons/lang3/ValidateTest.java
@@ -624,6 +624,39 @@ public class ValidateTest extends AbstractLangTest {
     }
 
     @Nested
+    class ValidState {
+
+        @Nested
+        class WitMessage {
+            @Test
+            void shouldNotThrowExceptionForValidIndex() {
+                Validate.validState(true, "The Message");
+            }
+
+            @Test
+            void shouldThrowExceptionForTrueExpression() {
+                assertThrows(IllegalStateException.class, () -> Validate.validState(false, "The Message"));
+            }
+
+        }
+
+        @Nested
+        class WithoutMessage {
+
+            @Test
+            void shouldNotThrowExceptionForTrueExpression() {
+                Validate.validState(true);
+            }
+
+            @Test
+            void shouldThrowExceptionForTrueExpression() {
+                assertThrows(IllegalStateException.class, () -> Validate.validState(false));
+            }
+
+        }
+    }
+
+    @Nested
     class ValidIndex {
 
         @Nested
@@ -764,8 +797,7 @@ public class ValidateTest extends AbstractLangTest {
 
                 @Test
                 void shouldThrowIndexOutOfBoundsExceptionWithGivenMessageForIndexOutOfBounds() {
-                    final IndexOutOfBoundsException ex = assertThrows(IndexOutOfBoundsException.class,
-                        () -> Validate.validIndex(Collections.singleton("a"), 1, "MSG"));
+                    final IndexOutOfBoundsException ex = assertThrows(IndexOutOfBoundsException.class, () -> Validate.validIndex(Collections.singleton("a"), 1, "MSG"));
                     assertEquals("MSG", ex.getMessage());
                 }
             }
diff --git a/src/test/java/org/apache/commons/lang3/builder/EqualsBuilderTest.java b/src/test/java/org/apache/commons/lang3/builder/EqualsBuilderTest.java
index 9e972760a..922162f75 100644
--- a/src/test/java/org/apache/commons/lang3/builder/EqualsBuilderTest.java
+++ b/src/test/java/org/apache/commons/lang3/builder/EqualsBuilderTest.java
@@ -24,6 +24,9 @@ import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 
 import org.apache.commons.lang3.AbstractLangTest;
 import org.apache.commons.lang3.reflect.MethodUtils;
@@ -445,6 +448,14 @@ public class EqualsBuilderTest extends AbstractLangTest {
     }
 
     @Test
+    public void testObjectsBypassReflectionClasses() {
+        final List<Class<?>> bypassReflectionClasses = new ArrayList<>();
+        bypassReflectionClasses.add(List.class);
+        bypassReflectionClasses.add(Boolean.class);
+        assertTrue(new EqualsBuilder().setBypassReflectionClasses(bypassReflectionClasses).isEquals());
+    }
+
+    @Test
     public void testObjectRecursiveGenericString() {
         // Note: Do not use literals, because string literals are always mapped by same object (internal() of String))!
         final String s1_a = String.valueOf(1);
@@ -1245,6 +1256,11 @@ public class EqualsBuilderTest extends AbstractLangTest {
         // still equal as long as both differing fields are among excluded
         assertTrue(EqualsBuilder.reflectionEquals(x1, x2, "one", "two", "three"));
         assertTrue(EqualsBuilder.reflectionEquals(x1, x2, "one", "two", "three", "xxx"));
+
+        // still equal as long as both differing fields are among excluded
+        assertTrue(EqualsBuilder.reflectionEquals(x1, x2, Arrays.asList("one", "two", "three")));
+        assertTrue(EqualsBuilder.reflectionEquals(x1, x2,  Arrays.asList("one", "two", "three", "xxx")));
+
     }
 
     static class TestObjectWithMultipleFields {
diff --git a/src/test/java/org/apache/commons/lang3/builder/StandardToStringStyleTest.java b/src/test/java/org/apache/commons/lang3/builder/StandardToStringStyleTest.java
index 291d40e32..fa183f513 100644
--- a/src/test/java/org/apache/commons/lang3/builder/StandardToStringStyleTest.java
+++ b/src/test/java/org/apache/commons/lang3/builder/StandardToStringStyleTest.java
@@ -50,6 +50,13 @@ public class StandardToStringStyleTest extends AbstractLangTest {
         STYLE.setSizeEndText("%");
         STYLE.setSummaryObjectStartText("%");
         STYLE.setSummaryObjectEndText("%");
+        STYLE.setUseClassName(true);
+        STYLE.setUseFieldNames(true);
+        STYLE.setUseClassName(true);
+        STYLE.setUseFieldNames(true);
+        STYLE.setDefaultFullDetail(true);
+        STYLE.setArrayContentDetail(true);
+        STYLE.setFieldNameValueSeparator("=");
     }
 
     @BeforeEach
@@ -188,4 +195,36 @@ public class StandardToStringStyleTest extends AbstractLangTest {
         assertTrue((new StandardToStringStyle()).isUseIdentityHashCode());
     }
 
+    @Test
+    public void testDefaultValueOfFullDetail() {
+        assertTrue((new StandardToStringStyle()).isDefaultFullDetail());
+    }
+
+    @Test
+    public void testDefaultIsArrayContentDetail() {
+        assertTrue((new StandardToStringStyle()).isArrayContentDetail());
+    }
+
+    @Test
+    public void testDefaultIsFieldSeparatorAtStart() {
+        assertFalse((new StandardToStringStyle()).isFieldSeparatorAtStart());
+    }
+
+    @Test
+    public void testDefaultIsFieldSeparatorAtEnd() {
+        assertFalse((new StandardToStringStyle()).isFieldSeparatorAtEnd());
+    }
+
+    @Test
+    public void testDefaultGetter() {
+        assertEquals("[", STYLE.getContentStart());
+        assertEquals("]", STYLE.getContentEnd());
+        assertEquals("=", STYLE.getFieldNameValueSeparator());
+        assertEquals(",", STYLE.getFieldSeparator());
+        assertEquals("%NULL%", STYLE.getNullText());
+        assertEquals("%SIZE=", STYLE.getSizeStartText());
+        assertEquals("%", STYLE.getSizeEndText());
+        assertEquals("%", STYLE.getSummaryObjectStartText());
+        assertEquals("%", STYLE.getSummaryObjectEndText());
+    }
 }
diff --git a/src/test/java/org/apache/commons/lang3/math/NumberUtilsTest.java b/src/test/java/org/apache/commons/lang3/math/NumberUtilsTest.java
index d2d3267eb..2a01fab16 100644
--- a/src/test/java/org/apache/commons/lang3/math/NumberUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/math/NumberUtilsTest.java
@@ -1249,6 +1249,7 @@ public class NumberUtilsTest extends AbstractLangTest {
         assertEquals(-10.45, NumberUtils.min(-10.45, -5.56, 0, 5.67, 10.78), "min(double[]) failed for array length 5");
         assertEquals(-10, NumberUtils.min(-10, -5, 0, 5, 10), 0.0001);
         assertEquals(-10, NumberUtils.min(-5, 0, -10, 5, 10), 0.0001);
+        assertEquals(5.12, NumberUtils.min(6.11, 5.12));
     }
 
     @Test
@@ -1268,6 +1269,8 @@ public class NumberUtilsTest extends AbstractLangTest {
         assertEquals(-10.6f, NumberUtils.min(-10.6f, -5.5f, 0, 5.4f, 10.3f), "min(float[]) failed for array length 5");
         assertEquals(-10, NumberUtils.min(-10, -5, 0, 5, 10), 0.0001f);
         assertEquals(-10, NumberUtils.min(-5, 0, -10, 5, 10), 0.0001f);
+        assertEquals(Float.NaN, NumberUtils.min(6.8f, Float.NaN));
+        assertEquals(3.7f, NumberUtils.min(6.8f, 3.7f));
     }
 
     @Test
diff --git a/src/test/java/org/apache/commons/lang3/tuple/ImmutablePairTest.java b/src/test/java/org/apache/commons/lang3/tuple/ImmutablePairTest.java
index 767423188..18e4ad6d6 100644
--- a/src/test/java/org/apache/commons/lang3/tuple/ImmutablePairTest.java
+++ b/src/test/java/org/apache/commons/lang3/tuple/ImmutablePairTest.java
@@ -250,4 +250,11 @@ public class ImmutablePairTest extends AbstractLangTest {
             assertEquals(item.getLeft() + "" + item.getRight(), entry.getValue());
         }
     }
+
+    @Test
+    public void testUnsupportedOperation() {
+        final ImmutablePair<Integer, String> pair = new ImmutablePair<>(0, "foo");
+        assertThrows(UnsupportedOperationException.class, () -> pair.setValue("any"));
+
+    }
 }