From e99b0dde8ee5069eaee745b62b57b109def4b22c Mon Sep 17 00:00:00 2001 From: Allon Mureinik Date: Thu, 11 Oct 2018 16:21:52 +0300 Subject: [PATCH] Update tests to JUnit Jupiter (closes #375) This patch finalizes the upgrade of commons-lang's tests to use JUnit Jupiter and remove the Vintage Engine dependency entirely. While most of these changes are drop-in replacements with no functional benefit, there are some non-obvious changes worth mentioning. Unlike org.junit.Assert.assertEquals(double, double, double), org.junit.jupiter.api.Assertions.assertEquals(double, double, double) does not support deltas of zero, only strictly positive deltas. This issue will be addressed in JUnit Jupiter 5.4 (see https://github.com/junit-team/junit5/pull/1613 for details). In the meanwhile, assertTrue(expected==actual) was used, and TODO comments were placed in the code to refactor it to assertEquals once JUnit 5.4 is available. Unlike org.junit.Test, org.junit.jupiter.api.Test does not have an "expected" argument. Instead, an explicit call to org.junit.jupiter.api.Assertions.assertThrows is used. Unlike org.junit.Test, org.junit.jupiter.api.Test does not have a "timeout" argument either. Instead, an explicit call to org.junit.jupiter.api.Assertions.assertTimeoutPreemptively is used. JUnit Jupiter also no longer has the concept of Rules. Usages of the SystemDefaultsSwitch rule and its accompanying annotates were replaced with the @DefaultLocale annotation that Benedikt Ritter contributed to JUnit Pioneer, the semi-official JUnit extension project. Following the removal of their usages, the SystemDefaults annotation, the SystemDefaultsSwitch rule and the SystemDefaultsSwitchTest class that tests them had no more use, and they were removed entirely. It's also worth noting this is a minimal patch for migrating the package's tests to Jupiter. There are several tests that can be made more elegant with Jupiter's new features, but that work is left for subsequent patches. --- pom.xml | 6 - .../commons/lang3/AnnotationUtilsTest.java | 134 +- .../apache/commons/lang3/ArchUtilsTest.java | 14 +- .../commons/lang3/ArrayUtilsAddTest.java | 14 +- .../commons/lang3/ArrayUtilsInsertTest.java | 10 +- .../lang3/ArrayUtilsRemoveMultipleTest.java | 121 +- .../commons/lang3/ArrayUtilsRemoveTest.java | 10 +- .../apache/commons/lang3/ArrayUtilsTest.java | 1085 +++++++---------- .../apache/commons/lang3/BitFieldTest.java | 8 +- .../commons/lang3/BooleanUtilsTest.java | 742 +++++------ .../commons/lang3/CharEncodingTest.java | 10 +- .../apache/commons/lang3/CharRangeTest.java | 17 +- .../commons/lang3/CharSequenceUtilsTest.java | 27 +- .../org/apache/commons/lang3/CharSetTest.java | 12 +- .../commons/lang3/CharSetUtilsTest.java | 12 +- .../apache/commons/lang3/CharUtilsTest.java | 16 +- .../commons/lang3/ClassPathUtilsTest.java | 65 +- .../apache/commons/lang3/ClassUtilsTest.java | 575 +++++---- .../apache/commons/lang3/ConversionTest.java | 10 +- .../apache/commons/lang3/EnumUtilsTest.java | 123 +- .../apache/commons/lang3/JavaVersionTest.java | 48 +- .../apache/commons/lang3/LocaleUtilsTest.java | 26 +- .../lang3/NotImplementedExceptionTest.java | 14 +- .../apache/commons/lang3/ObjectUtilsTest.java | 134 +- .../commons/lang3/RandomStringUtilsTest.java | 110 +- .../apache/commons/lang3/RandomUtilsTest.java | 67 +- .../org/apache/commons/lang3/RangeTest.java | 79 +- .../apache/commons/lang3/RegExUtilsTest.java | 8 +- .../commons/lang3/SerializationUtilsTest.java | 88 +- .../commons/lang3/StringEscapeUtilsTest.java | 147 ++- .../lang3/StringUtilsContainsTest.java | 26 +- .../lang3/StringUtilsEmptyBlankTest.java | 10 +- .../lang3/StringUtilsEqualsIndexOfTest.java | 16 +- .../commons/lang3/StringUtilsIsTest.java | 6 +- .../lang3/StringUtilsStartsEndsWithTest.java | 156 +-- .../lang3/StringUtilsSubstringTest.java | 8 +- .../apache/commons/lang3/StringUtilsTest.java | 513 ++++---- .../lang3/StringUtilsTrimStripTest.java | 24 +- .../apache/commons/lang3/SystemUtilsTest.java | 14 +- .../apache/commons/lang3/ThreadUtilsTest.java | 95 +- .../commons/lang3/test/SystemDefaults.java | 40 - .../lang3/test/SystemDefaultsSwitch.java | 113 -- .../lang3/test/SystemDefaultsSwitchTest.java | 89 -- 43 files changed, 2173 insertions(+), 2669 deletions(-) delete mode 100644 src/test/java/org/apache/commons/lang3/test/SystemDefaults.java delete mode 100644 src/test/java/org/apache/commons/lang3/test/SystemDefaultsSwitch.java delete mode 100644 src/test/java/org/apache/commons/lang3/test/SystemDefaultsSwitchTest.java diff --git a/pom.xml b/pom.xml index 5d69ade68..6875f8bcd 100644 --- a/pom.xml +++ b/pom.xml @@ -537,12 +537,6 @@ junit-jupiter-engine test - - - org.junit.vintage - junit-vintage-engine - test - org.junit-pioneer junit-pioneer diff --git a/src/test/java/org/apache/commons/lang3/AnnotationUtilsTest.java b/src/test/java/org/apache/commons/lang3/AnnotationUtilsTest.java index fc656aec4..fb129d01c 100644 --- a/src/test/java/org/apache/commons/lang3/AnnotationUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/AnnotationUtilsTest.java @@ -22,23 +22,26 @@ import static org.apache.commons.lang3.AnnotationUtilsTest.Stooge.CURLY; import static org.apache.commons.lang3.AnnotationUtilsTest.Stooge.LARRY; import static org.apache.commons.lang3.AnnotationUtilsTest.Stooge.MOE; import static org.apache.commons.lang3.AnnotationUtilsTest.Stooge.SHEMP; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; import java.lang.reflect.Array; import java.lang.reflect.Field; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; +import java.time.Duration; import java.util.Collection; import java.util.Map; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.BeforeEach; /** */ @@ -377,6 +380,17 @@ public class AnnotationUtilsTest { Stooge[] stooges(); } + @Retention(RetentionPolicy.RUNTIME) + @Target({ElementType.METHOD}) + public @interface TestMethodAnnotation { + Class expected() default None.class; + + long timeout() default 0L; + + class None extends Throwable { + } + } + public enum Stooge { MOE, LARRY, CURLY, JOE, SHEMP } @@ -386,7 +400,7 @@ public class AnnotationUtilsTest { private Field field3; private Field field4; - @Before + @BeforeEach public void setup() throws Exception { field1 = getClass().getDeclaredField("dummy1"); field2 = getClass().getDeclaredField("dummy2"); @@ -444,65 +458,73 @@ public class AnnotationUtilsTest { } } - @Test(timeout = 666000) - public void testGeneratedAnnotationEquivalentToRealAnnotation() throws Exception { - final Test real = getClass().getDeclaredMethod( - "testGeneratedAnnotationEquivalentToRealAnnotation").getAnnotation(Test.class); + @Test + public void testGeneratedAnnotationEquivalentToRealAnnotation() { + assertTimeoutPreemptively(Duration.ofSeconds(666L), () -> { + final Test real = getClass().getDeclaredMethod( + "testGeneratedAnnotationEquivalentToRealAnnotation").getAnnotation(Test.class); - final InvocationHandler generatedTestInvocationHandler = new InvocationHandler() { + final InvocationHandler generatedTestInvocationHandler = new InvocationHandler() { - @Override - public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable { - if ("equals".equals(method.getName()) && method.getParameterTypes().length == 1) { - return Boolean.valueOf(proxy == args[0]); + @Override + public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable { + if ("equals".equals(method.getName()) && method.getParameterTypes().length == 1) { + return Boolean.valueOf(proxy == args[0]); + } + if ("hashCode".equals(method.getName()) && method.getParameterTypes().length == 0) { + return Integer.valueOf(System.identityHashCode(proxy)); + } + if ("toString".equals(method.getName()) && method.getParameterTypes().length == 0) { + return "Test proxy"; + } + return method.invoke(real, args); } - if ("hashCode".equals(method.getName()) && method.getParameterTypes().length == 0) { - return Integer.valueOf(System.identityHashCode(proxy)); - } - if ("toString".equals(method.getName()) && method.getParameterTypes().length == 0) { - return "Test proxy"; - } - return method.invoke(real, args); - } - }; + }; - final Test generated = (Test) Proxy.newProxyInstance(Thread.currentThread() - .getContextClassLoader(), new Class[] { Test.class }, - generatedTestInvocationHandler); - assertTrue(real.equals(generated)); - assertFalse(generated.equals(real)); - assertTrue(AnnotationUtils.equals(generated, real)); - assertTrue(AnnotationUtils.equals(real, generated)); + final Test generated = (Test) Proxy.newProxyInstance(Thread.currentThread() + .getContextClassLoader(), new Class[]{Test.class}, + generatedTestInvocationHandler); + assertTrue(real.equals(generated)); + assertFalse(generated.equals(real)); + assertTrue(AnnotationUtils.equals(generated, real)); + assertTrue(AnnotationUtils.equals(real, generated)); - final Test generated2 = (Test) Proxy.newProxyInstance(Thread.currentThread() - .getContextClassLoader(), new Class[] { Test.class }, - generatedTestInvocationHandler); - assertFalse(generated.equals(generated2)); - assertFalse(generated2.equals(generated)); - assertTrue(AnnotationUtils.equals(generated, generated2)); - assertTrue(AnnotationUtils.equals(generated2, generated)); + final Test generated2 = (Test) Proxy.newProxyInstance(Thread.currentThread() + .getContextClassLoader(), new Class[]{Test.class}, + generatedTestInvocationHandler); + assertFalse(generated.equals(generated2)); + assertFalse(generated2.equals(generated)); + assertTrue(AnnotationUtils.equals(generated, generated2)); + assertTrue(AnnotationUtils.equals(generated2, generated)); + }); } - @Test(timeout = 666000) - public void testHashCode() throws Exception { - final Test test = getClass().getDeclaredMethod("testHashCode").getAnnotation(Test.class); - assertEquals(test.hashCode(), AnnotationUtils.hashCode(test)); - final TestAnnotation testAnnotation1 = field1.getAnnotation(TestAnnotation.class); - assertEquals(testAnnotation1.hashCode(), AnnotationUtils.hashCode(testAnnotation1)); - final TestAnnotation testAnnotation3 = field3.getAnnotation(TestAnnotation.class); - assertEquals(testAnnotation3.hashCode(), AnnotationUtils.hashCode(testAnnotation3)); + @Test + public void testHashCode() { + assertTimeoutPreemptively(Duration.ofSeconds(666L), () -> { + final Test test = getClass().getDeclaredMethod("testHashCode").getAnnotation(Test.class); + assertEquals(test.hashCode(), AnnotationUtils.hashCode(test)); + final TestAnnotation testAnnotation1 = field1.getAnnotation(TestAnnotation.class); + assertEquals(testAnnotation1.hashCode(), AnnotationUtils.hashCode(testAnnotation1)); + final TestAnnotation testAnnotation3 = field3.getAnnotation(TestAnnotation.class); + assertEquals(testAnnotation3.hashCode(), AnnotationUtils.hashCode(testAnnotation3)); + }); } - @Test(timeout = 666000) - public void testToString() throws Exception { - final Test testAnnotation = getClass().getDeclaredMethod("testToString") - .getAnnotation(Test.class); - final String annotationString = AnnotationUtils.toString(testAnnotation); - assertTrue(annotationString.startsWith("@org.junit.Test(")); - assertTrue(annotationString.endsWith(")")); - assertTrue(annotationString.contains("expected=class org.junit.Test$None")); - assertTrue(annotationString.contains("timeout=666000")); - assertTrue(annotationString.contains(", ")); + @Test + @TestMethodAnnotation(timeout = 666000) + public void testToString() { + assertTimeoutPreemptively(Duration.ofSeconds(666L), () -> { + final TestMethodAnnotation testAnnotation = + getClass().getDeclaredMethod("testToString").getAnnotation(TestMethodAnnotation.class); + + final String annotationString = AnnotationUtils.toString(testAnnotation); + assertTrue(annotationString.startsWith("@org.apache.commons.lang3.AnnotationUtilsTest$TestMethodAnnotation(")); + assertTrue(annotationString.endsWith(")")); + assertTrue(annotationString.contains("expected=class org.apache.commons.lang3.AnnotationUtilsTest$TestMethodAnnotation$None")); + assertTrue(annotationString.contains("timeout=666000")); + assertTrue(annotationString.contains(", ")); + }); } } diff --git a/src/test/java/org/apache/commons/lang3/ArchUtilsTest.java b/src/test/java/org/apache/commons/lang3/ArchUtilsTest.java index a20379c1e..ead1183b5 100644 --- a/src/test/java/org/apache/commons/lang3/ArchUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/ArchUtilsTest.java @@ -17,14 +17,14 @@ package org.apache.commons.lang3; import org.apache.commons.lang3.arch.Processor; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; /** * Test class for {@link ArchUtils}. diff --git a/src/test/java/org/apache/commons/lang3/ArrayUtilsAddTest.java b/src/test/java/org/apache/commons/lang3/ArrayUtilsAddTest.java index a05842774..ce7ed2c11 100644 --- a/src/test/java/org/apache/commons/lang3/ArrayUtilsAddTest.java +++ b/src/test/java/org/apache/commons/lang3/ArrayUtilsAddTest.java @@ -17,16 +17,16 @@ package org.apache.commons.lang3; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNotSame; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; import java.util.Arrays; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Tests ArrayUtils add methods. diff --git a/src/test/java/org/apache/commons/lang3/ArrayUtilsInsertTest.java b/src/test/java/org/apache/commons/lang3/ArrayUtilsInsertTest.java index 2a0a23f4a..a3bfbf48f 100644 --- a/src/test/java/org/apache/commons/lang3/ArrayUtilsInsertTest.java +++ b/src/test/java/org/apache/commons/lang3/ArrayUtilsInsertTest.java @@ -17,12 +17,12 @@ package org.apache.commons.lang3; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.fail; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Tests ArrayUtils insert methods. diff --git a/src/test/java/org/apache/commons/lang3/ArrayUtilsRemoveMultipleTest.java b/src/test/java/org/apache/commons/lang3/ArrayUtilsRemoveMultipleTest.java index 9e596d4a7..74e7e3ce2 100644 --- a/src/test/java/org/apache/commons/lang3/ArrayUtilsRemoveMultipleTest.java +++ b/src/test/java/org/apache/commons/lang3/ArrayUtilsRemoveMultipleTest.java @@ -17,15 +17,16 @@ package org.apache.commons.lang3; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotSame; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.Arrays; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Tests ArrayUtils remove and removeElement methods. @@ -90,19 +91,19 @@ public class ArrayUtilsRemoveMultipleTest { assertEquals(Object.class, array2.getClass().getComponentType()); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllObjectArrayNegativeIndex() { - ArrayUtils.removeAll(new Object[] { "a", "b" }, -1); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new Object[] { "a", "b" }, -1)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllObjectArrayOutOfBoundsIndex() { - ArrayUtils.removeAll(new Object[] { "a", "b" }, 2); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new Object[] { "a", "b" }, 2)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllNullObjectArray() { - ArrayUtils.remove((Object[]) null, 0); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.remove((Object[]) null, 0)); } @Test @@ -206,19 +207,19 @@ public class ArrayUtilsRemoveMultipleTest { assertEquals(boolean.class, array2.getClass().getComponentType()); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllBooleanArrayNegativeIndex() { - ArrayUtils.removeAll(new boolean[] { true, false }, -1); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new boolean[] { true, false }, -1)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllBooleanArrayOutOfBoundsIndex() { - ArrayUtils.removeAll(new boolean[] { true, false }, 2); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new boolean[] { true, false }, 2)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllNullBooleanArray() { - ArrayUtils.removeAll((boolean[]) null, 0); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll((boolean[]) null, 0)); } @Test @@ -283,19 +284,19 @@ public class ArrayUtilsRemoveMultipleTest { assertEquals(byte.class, array2.getClass().getComponentType()); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllByteArrayNegativeIndex() { - ArrayUtils.removeAll(new byte[] { 1, 2 }, -1); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new byte[] { 1, 2 }, -1)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllByteArrayOutOfBoundsIndex() { - ArrayUtils.removeAll(new byte[] { 1, 2 }, 2); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new byte[] { 1, 2 }, 2)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllNullByteArray() { - ArrayUtils.removeAll((byte[]) null, 0); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll((byte[]) null, 0)); } @Test @@ -360,19 +361,19 @@ public class ArrayUtilsRemoveMultipleTest { assertEquals(char.class, array2.getClass().getComponentType()); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllCharArrayNegativeIndex() { - ArrayUtils.removeAll(new char[] { 'a', 'b' }, -1); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new char[] { 'a', 'b' }, -1)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllCharArrayOutOfBoundsIndex() { - ArrayUtils.removeAll(new char[] { 'a', 'b' }, 2); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new char[] { 'a', 'b' }, 2)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllNullCharArray() { - ArrayUtils.removeAll((char[]) null, 0); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll((char[]) null, 0)); } @Test @@ -437,19 +438,19 @@ public class ArrayUtilsRemoveMultipleTest { assertEquals(double.class, array2.getClass().getComponentType()); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllDoubleArrayNegativeIndex() { - ArrayUtils.removeAll(new double[] { 1, 2 }, -1); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new double[] { 1, 2 }, -1)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllDoubleArrayOutOfBoundsIndex() { - ArrayUtils.removeAll(new double[] { 1, 2 }, 2); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new double[] { 1, 2 }, 2)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllNullDoubleArray() { - ArrayUtils.removeAll((double[]) null, 0); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll((double[]) null, 0)); } @Test @@ -514,19 +515,19 @@ public class ArrayUtilsRemoveMultipleTest { assertEquals(float.class, array2.getClass().getComponentType()); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllFloatArrayNegativeIndex() { - ArrayUtils.removeAll(new float[] { 1, 2 }, -1); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new float[] { 1, 2 }, -1)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllFloatArrayOutOfBoundsIndex() { - ArrayUtils.removeAll(new float[] { 1, 2 }, 2); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new float[] { 1, 2 }, 2)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllNullFloatArray() { - ArrayUtils.removeAll((float[]) null, 0); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll((float[]) null, 0)); } @Test @@ -597,19 +598,19 @@ public class ArrayUtilsRemoveMultipleTest { assertEquals(int.class, array2.getClass().getComponentType()); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllIntArrayNegativeIndex() { - ArrayUtils.removeAll(new int[] { 1, 2 }, -1); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new int[] { 1, 2 }, -1)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllIntArrayOutOfBoundsIndex() { - ArrayUtils.removeAll(new int[] { 1, 2 }, 2); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new int[] { 1, 2 }, 2)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllNullIntArray() { - ArrayUtils.removeAll((int[]) null, 0); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll((int[]) null, 0)); } @Test @@ -674,19 +675,19 @@ public class ArrayUtilsRemoveMultipleTest { assertEquals(long.class, array2.getClass().getComponentType()); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllLongArrayNegativeIndex() { - ArrayUtils.removeAll(new long[] { 1, 2 }, -1); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new long[] { 1, 2 }, -1)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllLongArrayOutOfBoundsIndex() { - ArrayUtils.removeAll(new long[] { 1, 2 }, 2); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new long[] { 1, 2 }, 2)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllNullLongArray() { - ArrayUtils.removeAll((long[]) null, 0); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll((long[]) null, 0)); } @Test @@ -751,19 +752,19 @@ public class ArrayUtilsRemoveMultipleTest { assertEquals(short.class, array2.getClass().getComponentType()); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllShortArrayNegativeIndex() { - ArrayUtils.removeAll(new short[] { 1, 2 }, -1, 0); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new short[] { 1, 2 }, -1, 0)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllShortArrayOutOfBoundsIndex() { - ArrayUtils.removeAll(new short[] { 1, 2 }, 2, 0); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new short[] { 1, 2 }, 2, 0)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRemoveAllNullShortArray() { - ArrayUtils.removeAll((short[]) null, 0); + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll((short[]) null, 0)); } @Test diff --git a/src/test/java/org/apache/commons/lang3/ArrayUtilsRemoveTest.java b/src/test/java/org/apache/commons/lang3/ArrayUtilsRemoveTest.java index 95ea490f3..9bb46c148 100644 --- a/src/test/java/org/apache/commons/lang3/ArrayUtilsRemoveTest.java +++ b/src/test/java/org/apache/commons/lang3/ArrayUtilsRemoveTest.java @@ -17,14 +17,14 @@ package org.apache.commons.lang3; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; import java.util.Arrays; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Tests ArrayUtils remove and removeElement methods. diff --git a/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java b/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java index 335b9a4a5..c049b973b 100644 --- a/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java @@ -16,15 +16,16 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNotSame; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +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.lang.reflect.Constructor; import java.lang.reflect.Modifier; @@ -34,7 +35,7 @@ import java.util.Date; import java.util.Map; import java.util.Random; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Unit tests {@link org.apache.commons.lang3.ArrayUtils}. @@ -394,10 +395,10 @@ public class ArrayUtilsTest { assertSame(input, output); } - @Test(expected = IllegalArgumentException.class) + @Test public void testNullToEmptyGenericNullType() { final TestClass[] input = new TestClass[]{}; - ArrayUtils.nullToEmpty(input, null); + assertThrows(IllegalArgumentException.class, () -> ArrayUtils.nullToEmpty(input, null)); } @Test @@ -768,41 +769,32 @@ public class ArrayUtilsTest { final Object[] nullArray = null; final Object[] objectArray = {"a", "b", "c", "d", "e", "f"}; - assertEquals("0 start, mid end", "abcd", - StringUtils.join(ArrayUtils.subarray(objectArray, 0, 4))); - assertEquals("0 start, length end", "abcdef", - StringUtils.join(ArrayUtils.subarray(objectArray, 0, objectArray.length))); - assertEquals("mid start, mid end", "bcd", - StringUtils.join(ArrayUtils.subarray(objectArray, 1, 4))); - assertEquals("mid start, length end", "bcdef", - StringUtils.join(ArrayUtils.subarray(objectArray, 1, objectArray.length))); + assertEquals("abcd", StringUtils.join(ArrayUtils.subarray(objectArray, 0, 4)), "0 start, mid end"); + assertEquals("abcdef", StringUtils.join(ArrayUtils.subarray(objectArray, 0, objectArray.length)), + "0 start, length end"); + assertEquals("bcd", StringUtils.join(ArrayUtils.subarray(objectArray, 1, 4)), "mid start, mid end"); + assertEquals("bcdef", StringUtils.join(ArrayUtils.subarray(objectArray, 1, objectArray.length)), + "mid start, length end"); - assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3)); - assertEquals("empty array", "", - StringUtils.join(ArrayUtils.subarray(ArrayUtils.EMPTY_OBJECT_ARRAY, 1, 2))); - assertEquals("start > end", "", - StringUtils.join(ArrayUtils.subarray(objectArray, 4, 2))); - assertEquals("start == end", "", - StringUtils.join(ArrayUtils.subarray(objectArray, 3, 3))); - assertEquals("start undershoot, normal end", "abcd", - StringUtils.join(ArrayUtils.subarray(objectArray, -2, 4))); - assertEquals("start overshoot, any end", "", - StringUtils.join(ArrayUtils.subarray(objectArray, 33, 4))); - assertEquals("normal start, end overshoot", "cdef", - StringUtils.join(ArrayUtils.subarray(objectArray, 2, 33))); - assertEquals("start undershoot, end overshoot", "abcdef", - StringUtils.join(ArrayUtils.subarray(objectArray, -2, 12))); + assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input"); + assertEquals("", StringUtils.join(ArrayUtils.subarray(ArrayUtils.EMPTY_OBJECT_ARRAY, 1, 2)), "empty array"); + assertEquals("", StringUtils.join(ArrayUtils.subarray(objectArray, 4, 2)), "start > end"); + assertEquals("", StringUtils.join(ArrayUtils.subarray(objectArray, 3, 3)), "start == end"); + assertEquals("abcd", StringUtils.join(ArrayUtils.subarray(objectArray, -2, 4)), "start undershoot, normal end"); + assertEquals("", StringUtils.join(ArrayUtils.subarray(objectArray, 33, 4)), "start overshoot, any end"); + assertEquals("cdef", StringUtils.join(ArrayUtils.subarray(objectArray, 2, 33)), "normal start, end overshoot"); + assertEquals("abcdef", StringUtils.join(ArrayUtils.subarray(objectArray, -2, 12)), + "start undershoot, end overshoot"); // array type tests final Date[] dateArray = {new java.sql.Date(new Date().getTime()), new Date(), new Date(), new Date(), new Date()}; - assertSame("Object type", Object.class, - ArrayUtils.subarray(objectArray, 2, 4).getClass().getComponentType()); - assertSame("java.util.Date type", java.util.Date.class, - ArrayUtils.subarray(dateArray, 1, 4).getClass().getComponentType()); - assertNotSame("java.sql.Date type", java.sql.Date.class, - ArrayUtils.subarray(dateArray, 1, 4).getClass().getComponentType()); + assertSame(Object.class, ArrayUtils.subarray(objectArray, 2, 4).getClass().getComponentType(), "Object type"); + assertSame(Date.class, ArrayUtils.subarray(dateArray, 1, 4).getClass().getComponentType(), + "java.util.Date type"); + assertNotSame(java.sql.Date.class, ArrayUtils.subarray(dateArray, 1, 4).getClass().getComponentType(), + "java.sql.Date type"); try { @SuppressWarnings("unused") final java.sql.Date[] dummy = (java.sql.Date[]) ArrayUtils.subarray(dateArray, 1, 3); fail("Invalid downcast"); @@ -818,72 +810,49 @@ public class ArrayUtilsTest { final long[] midSubarray = {999911, 999912, 999913, 999914}; final long[] rightSubarray = {999912, 999913, 999914, 999915}; - assertTrue("0 start, mid end", - ArrayUtils.isEquals(leftSubarray, - ArrayUtils.subarray(array, 0, 4))); + assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end"); - assertTrue("0 start, length end", - ArrayUtils.isEquals(array, - ArrayUtils.subarray(array, 0, array.length))); + assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end"); - assertTrue("mid start, mid end", - ArrayUtils.isEquals(midSubarray, - ArrayUtils.subarray(array, 1, 5))); + assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end"); - assertTrue("mid start, length end", - ArrayUtils.isEquals(rightSubarray, - ArrayUtils.subarray(array, 2, array.length))); + assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), + "mid start, length end"); + assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input"); - assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3)); + assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_LONG_ARRAY, 1, 2), + "empty array"); - assertEquals("empty array", ArrayUtils.EMPTY_LONG_ARRAY, - ArrayUtils.subarray(ArrayUtils.EMPTY_LONG_ARRAY, 1, 2)); + assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end"); - assertEquals("start > end", ArrayUtils.EMPTY_LONG_ARRAY, - ArrayUtils.subarray(array, 4, 2)); + assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end"); - assertEquals("start == end", ArrayUtils.EMPTY_LONG_ARRAY, - ArrayUtils.subarray(array, 3, 3)); + assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), + "start undershoot, normal end"); - assertTrue("start undershoot, normal end", - ArrayUtils.isEquals(leftSubarray, - ArrayUtils.subarray(array, -2, 4))); + assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end"); - assertEquals("start overshoot, any end", - ArrayUtils.EMPTY_LONG_ARRAY, - ArrayUtils.subarray(array, 33, 4)); + assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), + "normal start, end overshoot"); - assertTrue("normal start, end overshoot", - ArrayUtils.isEquals(rightSubarray, - ArrayUtils.subarray(array, 2, 33))); - - assertTrue("start undershoot, end overshoot", - ArrayUtils.isEquals(array, - ArrayUtils.subarray(array, -2, 12))); + assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot"); // empty-return tests - assertSame("empty array, object test", - ArrayUtils.EMPTY_LONG_ARRAY, - ArrayUtils.subarray(ArrayUtils.EMPTY_LONG_ARRAY, 1, 2)); + assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_LONG_ARRAY, 1, 2), + "empty array, object test"); - assertSame("start > end, object test", - ArrayUtils.EMPTY_LONG_ARRAY, - ArrayUtils.subarray(array, 4, 1)); + assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test"); - assertSame("start == end, object test", - ArrayUtils.EMPTY_LONG_ARRAY, - ArrayUtils.subarray(array, 3, 3)); + assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test"); - assertSame("start overshoot, any end, object test", - ArrayUtils.EMPTY_LONG_ARRAY, - ArrayUtils.subarray(array, 8733, 4)); + assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 8733, 4), + "start overshoot, any end, object test"); // array type tests - assertSame("long type", long.class, - ArrayUtils.subarray(array, 2, 4).getClass().getComponentType()); + assertSame(long.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "long type"); } @@ -896,73 +865,49 @@ public class ArrayUtilsTest { final int[] rightSubarray = {12, 13, 14, 15}; - assertTrue("0 start, mid end", - ArrayUtils.isEquals(leftSubarray, - ArrayUtils.subarray(array, 0, 4))); + assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end"); - assertTrue("0 start, length end", - ArrayUtils.isEquals(array, - ArrayUtils.subarray(array, 0, array.length))); + assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end"); - assertTrue("mid start, mid end", - ArrayUtils.isEquals(midSubarray, - ArrayUtils.subarray(array, 1, 5))); + assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end"); - assertTrue("mid start, length end", - ArrayUtils.isEquals(rightSubarray, - ArrayUtils.subarray(array, 2, array.length))); + assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), + "mid start, length end"); - assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3)); + assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input"); - assertEquals("empty array", ArrayUtils.EMPTY_INT_ARRAY, - ArrayUtils.subarray(ArrayUtils.EMPTY_INT_ARRAY, 1, 2)); + assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_INT_ARRAY, 1, 2), "empty array"); - assertEquals("start > end", ArrayUtils.EMPTY_INT_ARRAY, - ArrayUtils.subarray(array, 4, 2)); + assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end"); - assertEquals("start == end", ArrayUtils.EMPTY_INT_ARRAY, - ArrayUtils.subarray(array, 3, 3)); + assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end"); - assertTrue("start undershoot, normal end", - ArrayUtils.isEquals(leftSubarray, - ArrayUtils.subarray(array, -2, 4))); + assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), + "start undershoot, normal end"); - assertEquals("start overshoot, any end", - ArrayUtils.EMPTY_INT_ARRAY, - ArrayUtils.subarray(array, 33, 4)); + assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end"); - assertTrue("normal start, end overshoot", - ArrayUtils.isEquals(rightSubarray, - ArrayUtils.subarray(array, 2, 33))); + assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), + "normal start, end overshoot"); - assertTrue("start undershoot, end overshoot", - ArrayUtils.isEquals(array, - ArrayUtils.subarray(array, -2, 12))); + assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot"); // empty-return tests - assertSame("empty array, object test", - ArrayUtils.EMPTY_INT_ARRAY, - ArrayUtils.subarray(ArrayUtils.EMPTY_INT_ARRAY, 1, 2)); + assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_INT_ARRAY, 1, 2), + "empty array, object test"); - assertSame("start > end, object test", - ArrayUtils.EMPTY_INT_ARRAY, - ArrayUtils.subarray(array, 4, 1)); + assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test"); - assertSame("start == end, object test", - ArrayUtils.EMPTY_INT_ARRAY, - ArrayUtils.subarray(array, 3, 3)); + assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test"); - assertSame("start overshoot, any end, object test", - ArrayUtils.EMPTY_INT_ARRAY, - ArrayUtils.subarray(array, 8733, 4)); + assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 8733, 4), + "start overshoot, any end, object test"); // array type tests - assertSame("int type", int.class, - ArrayUtils.subarray(array, 2, 4).getClass().getComponentType()); - + assertSame(int.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "int type"); } @Test @@ -973,74 +918,36 @@ public class ArrayUtilsTest { final short[] midSubarray = {11, 12, 13, 14}; final short[] rightSubarray = {12, 13, 14, 15}; + assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end"); + assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end"); + assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end"); + assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), + "mid start, length end"); - assertTrue("0 start, mid end", - ArrayUtils.isEquals(leftSubarray, - ArrayUtils.subarray(array, 0, 4))); - - assertTrue("0 start, length end", - ArrayUtils.isEquals(array, - ArrayUtils.subarray(array, 0, array.length))); - - assertTrue("mid start, mid end", - ArrayUtils.isEquals(midSubarray, - ArrayUtils.subarray(array, 1, 5))); - - assertTrue("mid start, length end", - ArrayUtils.isEquals(rightSubarray, - ArrayUtils.subarray(array, 2, array.length))); - - - assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3)); - - assertEquals("empty array", ArrayUtils.EMPTY_SHORT_ARRAY, - ArrayUtils.subarray(ArrayUtils.EMPTY_SHORT_ARRAY, 1, 2)); - - assertEquals("start > end", ArrayUtils.EMPTY_SHORT_ARRAY, - ArrayUtils.subarray(array, 4, 2)); - - assertEquals("start == end", ArrayUtils.EMPTY_SHORT_ARRAY, - ArrayUtils.subarray(array, 3, 3)); - - assertTrue("start undershoot, normal end", - ArrayUtils.isEquals(leftSubarray, - ArrayUtils.subarray(array, -2, 4))); - - assertEquals("start overshoot, any end", - ArrayUtils.EMPTY_SHORT_ARRAY, - ArrayUtils.subarray(array, 33, 4)); - - assertTrue("normal start, end overshoot", - ArrayUtils.isEquals(rightSubarray, - ArrayUtils.subarray(array, 2, 33))); - - assertTrue("start undershoot, end overshoot", - ArrayUtils.isEquals(array, - ArrayUtils.subarray(array, -2, 12))); + assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input"); + assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_SHORT_ARRAY, 1, 2), + "empty array"); + assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end"); + assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end"); + assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), + "start undershoot, normal end"); + assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end"); + assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), + "normal start, end overshoot"); + assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot"); // empty-return tests - assertSame("empty array, object test", - ArrayUtils.EMPTY_SHORT_ARRAY, - ArrayUtils.subarray(ArrayUtils.EMPTY_SHORT_ARRAY, 1, 2)); - - assertSame("start > end, object test", - ArrayUtils.EMPTY_SHORT_ARRAY, - ArrayUtils.subarray(array, 4, 1)); - - assertSame("start == end, object test", - ArrayUtils.EMPTY_SHORT_ARRAY, - ArrayUtils.subarray(array, 3, 3)); - - assertSame("start overshoot, any end, object test", - ArrayUtils.EMPTY_SHORT_ARRAY, - ArrayUtils.subarray(array, 8733, 4)); + assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_SHORT_ARRAY, 1, 2), + "empty array, object test"); + assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test"); + assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test"); + assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 8733, 4), + "start overshoot, any end, object test"); // array type tests - assertSame("short type", short.class, - ArrayUtils.subarray(array, 2, 4).getClass().getComponentType()); - + assertSame(short.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "short type"); } @Test @@ -1051,74 +958,36 @@ public class ArrayUtilsTest { final char[] midSubarray = {'b', 'c', 'd', 'e',}; final char[] rightSubarray = {'c', 'd', 'e', 'f',}; + assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end"); + assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end"); + assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end"); + assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), + "mid start, length end"); - assertTrue("0 start, mid end", - ArrayUtils.isEquals(leftSubarray, - ArrayUtils.subarray(array, 0, 4))); - - assertTrue("0 start, length end", - ArrayUtils.isEquals(array, - ArrayUtils.subarray(array, 0, array.length))); - - assertTrue("mid start, mid end", - ArrayUtils.isEquals(midSubarray, - ArrayUtils.subarray(array, 1, 5))); - - assertTrue("mid start, length end", - ArrayUtils.isEquals(rightSubarray, - ArrayUtils.subarray(array, 2, array.length))); - - - assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3)); - - assertEquals("empty array", ArrayUtils.EMPTY_CHAR_ARRAY, - ArrayUtils.subarray(ArrayUtils.EMPTY_CHAR_ARRAY, 1, 2)); - - assertEquals("start > end", ArrayUtils.EMPTY_CHAR_ARRAY, - ArrayUtils.subarray(array, 4, 2)); - - assertEquals("start == end", ArrayUtils.EMPTY_CHAR_ARRAY, - ArrayUtils.subarray(array, 3, 3)); - - assertTrue("start undershoot, normal end", - ArrayUtils.isEquals(leftSubarray, - ArrayUtils.subarray(array, -2, 4))); - - assertEquals("start overshoot, any end", - ArrayUtils.EMPTY_CHAR_ARRAY, - ArrayUtils.subarray(array, 33, 4)); - - assertTrue("normal start, end overshoot", - ArrayUtils.isEquals(rightSubarray, - ArrayUtils.subarray(array, 2, 33))); - - assertTrue("start undershoot, end overshoot", - ArrayUtils.isEquals(array, - ArrayUtils.subarray(array, -2, 12))); + assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input"); + assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_CHAR_ARRAY, 1, 2), + "empty array"); + assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end"); + assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end"); + assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), + "start undershoot, normal end"); + assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end"); + assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), + "normal start, end overshoot"); + assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot"); // empty-return tests - assertSame("empty array, object test", - ArrayUtils.EMPTY_CHAR_ARRAY, - ArrayUtils.subarray(ArrayUtils.EMPTY_CHAR_ARRAY, 1, 2)); - - assertSame("start > end, object test", - ArrayUtils.EMPTY_CHAR_ARRAY, - ArrayUtils.subarray(array, 4, 1)); - - assertSame("start == end, object test", - ArrayUtils.EMPTY_CHAR_ARRAY, - ArrayUtils.subarray(array, 3, 3)); - - assertSame("start overshoot, any end, object test", - ArrayUtils.EMPTY_CHAR_ARRAY, - ArrayUtils.subarray(array, 8733, 4)); + assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_CHAR_ARRAY, 1, 2), + "empty array, object test"); + assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test"); + assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test"); + assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 8733, 4), + "start overshoot, any end, object test"); // array type tests - assertSame("char type", char.class, - ArrayUtils.subarray(array, 2, 4).getClass().getComponentType()); - + assertSame(char.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "char type"); } @Test @@ -1129,74 +998,36 @@ public class ArrayUtilsTest { final byte[] midSubarray = {11, 12, 13, 14}; final byte[] rightSubarray = {12, 13, 14, 15}; + assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end"); + assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end"); + assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end"); + assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), + "mid start, length end"); - assertTrue("0 start, mid end", - ArrayUtils.isEquals(leftSubarray, - ArrayUtils.subarray(array, 0, 4))); - - assertTrue("0 start, length end", - ArrayUtils.isEquals(array, - ArrayUtils.subarray(array, 0, array.length))); - - assertTrue("mid start, mid end", - ArrayUtils.isEquals(midSubarray, - ArrayUtils.subarray(array, 1, 5))); - - assertTrue("mid start, length end", - ArrayUtils.isEquals(rightSubarray, - ArrayUtils.subarray(array, 2, array.length))); - - - assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3)); - - assertEquals("empty array", ArrayUtils.EMPTY_BYTE_ARRAY, - ArrayUtils.subarray(ArrayUtils.EMPTY_BYTE_ARRAY, 1, 2)); - - assertEquals("start > end", ArrayUtils.EMPTY_BYTE_ARRAY, - ArrayUtils.subarray(array, 4, 2)); - - assertEquals("start == end", ArrayUtils.EMPTY_BYTE_ARRAY, - ArrayUtils.subarray(array, 3, 3)); - - assertTrue("start undershoot, normal end", - ArrayUtils.isEquals(leftSubarray, - ArrayUtils.subarray(array, -2, 4))); - - assertEquals("start overshoot, any end", - ArrayUtils.EMPTY_BYTE_ARRAY, - ArrayUtils.subarray(array, 33, 4)); - - assertTrue("normal start, end overshoot", - ArrayUtils.isEquals(rightSubarray, - ArrayUtils.subarray(array, 2, 33))); - - assertTrue("start undershoot, end overshoot", - ArrayUtils.isEquals(array, - ArrayUtils.subarray(array, -2, 12))); + assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input"); + assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_BYTE_ARRAY, 1, 2), + "empty array"); + assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end"); + assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end"); + assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), + "start undershoot, normal end"); + assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end"); + assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), + "normal start, end overshoot"); + assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot"); // empty-return tests - assertSame("empty array, object test", - ArrayUtils.EMPTY_BYTE_ARRAY, - ArrayUtils.subarray(ArrayUtils.EMPTY_BYTE_ARRAY, 1, 2)); - - assertSame("start > end, object test", - ArrayUtils.EMPTY_BYTE_ARRAY, - ArrayUtils.subarray(array, 4, 1)); - - assertSame("start == end, object test", - ArrayUtils.EMPTY_BYTE_ARRAY, - ArrayUtils.subarray(array, 3, 3)); - - assertSame("start overshoot, any end, object test", - ArrayUtils.EMPTY_BYTE_ARRAY, - ArrayUtils.subarray(array, 8733, 4)); + assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_BYTE_ARRAY, 1, 2), + "empty array, object test"); + assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test"); + assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test"); + assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 8733, 4), + "start overshoot, any end, object test"); // array type tests - assertSame("byte type", byte.class, - ArrayUtils.subarray(array, 2, 4).getClass().getComponentType()); - + assertSame(byte.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "byte type"); } @Test @@ -1207,74 +1038,36 @@ public class ArrayUtilsTest { final double[] midSubarray = {11.234, 12.345, 13.456, 14.567,}; final double[] rightSubarray = {12.345, 13.456, 14.567, 15.678}; + assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end"); + assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end"); + assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end"); + assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), + "mid start, length end"); - assertTrue("0 start, mid end", - ArrayUtils.isEquals(leftSubarray, - ArrayUtils.subarray(array, 0, 4))); - - assertTrue("0 start, length end", - ArrayUtils.isEquals(array, - ArrayUtils.subarray(array, 0, array.length))); - - assertTrue("mid start, mid end", - ArrayUtils.isEquals(midSubarray, - ArrayUtils.subarray(array, 1, 5))); - - assertTrue("mid start, length end", - ArrayUtils.isEquals(rightSubarray, - ArrayUtils.subarray(array, 2, array.length))); - - - assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3)); - - assertEquals("empty array", ArrayUtils.EMPTY_DOUBLE_ARRAY, - ArrayUtils.subarray(ArrayUtils.EMPTY_DOUBLE_ARRAY, 1, 2)); - - assertEquals("start > end", ArrayUtils.EMPTY_DOUBLE_ARRAY, - ArrayUtils.subarray(array, 4, 2)); - - assertEquals("start == end", ArrayUtils.EMPTY_DOUBLE_ARRAY, - ArrayUtils.subarray(array, 3, 3)); - - assertTrue("start undershoot, normal end", - ArrayUtils.isEquals(leftSubarray, - ArrayUtils.subarray(array, -2, 4))); - - assertEquals("start overshoot, any end", - ArrayUtils.EMPTY_DOUBLE_ARRAY, - ArrayUtils.subarray(array, 33, 4)); - - assertTrue("normal start, end overshoot", - ArrayUtils.isEquals(rightSubarray, - ArrayUtils.subarray(array, 2, 33))); - - assertTrue("start undershoot, end overshoot", - ArrayUtils.isEquals(array, - ArrayUtils.subarray(array, -2, 12))); + assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input"); + assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_DOUBLE_ARRAY, 1, 2), + "empty array"); + assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end"); + assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end"); + assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), + "start undershoot, normal end"); + assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end"); + assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), + "normal start, end overshoot"); + assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot"); // empty-return tests - assertSame("empty array, object test", - ArrayUtils.EMPTY_DOUBLE_ARRAY, - ArrayUtils.subarray(ArrayUtils.EMPTY_DOUBLE_ARRAY, 1, 2)); - - assertSame("start > end, object test", - ArrayUtils.EMPTY_DOUBLE_ARRAY, - ArrayUtils.subarray(array, 4, 1)); - - assertSame("start == end, object test", - ArrayUtils.EMPTY_DOUBLE_ARRAY, - ArrayUtils.subarray(array, 3, 3)); - - assertSame("start overshoot, any end, object test", - ArrayUtils.EMPTY_DOUBLE_ARRAY, - ArrayUtils.subarray(array, 8733, 4)); + assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_DOUBLE_ARRAY, 1, 2), + "empty array, object test"); + assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test"); + assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test"); + assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 8733, 4), + "start overshoot, any end, object test"); // array type tests - assertSame("double type", double.class, - ArrayUtils.subarray(array, 2, 4).getClass().getComponentType()); - + assertSame(double.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "double type"); } @Test @@ -1285,74 +1078,36 @@ public class ArrayUtilsTest { final float[] midSubarray = {11, 12, 13, 14}; final float[] rightSubarray = {12, 13, 14, 15}; + assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end"); + assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end"); + assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end"); + assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), + "mid start, length end"); - assertTrue("0 start, mid end", - ArrayUtils.isEquals(leftSubarray, - ArrayUtils.subarray(array, 0, 4))); - - assertTrue("0 start, length end", - ArrayUtils.isEquals(array, - ArrayUtils.subarray(array, 0, array.length))); - - assertTrue("mid start, mid end", - ArrayUtils.isEquals(midSubarray, - ArrayUtils.subarray(array, 1, 5))); - - assertTrue("mid start, length end", - ArrayUtils.isEquals(rightSubarray, - ArrayUtils.subarray(array, 2, array.length))); - - - assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3)); - - assertEquals("empty array", ArrayUtils.EMPTY_FLOAT_ARRAY, - ArrayUtils.subarray(ArrayUtils.EMPTY_FLOAT_ARRAY, 1, 2)); - - assertEquals("start > end", ArrayUtils.EMPTY_FLOAT_ARRAY, - ArrayUtils.subarray(array, 4, 2)); - - assertEquals("start == end", ArrayUtils.EMPTY_FLOAT_ARRAY, - ArrayUtils.subarray(array, 3, 3)); - - assertTrue("start undershoot, normal end", - ArrayUtils.isEquals(leftSubarray, - ArrayUtils.subarray(array, -2, 4))); - - assertEquals("start overshoot, any end", - ArrayUtils.EMPTY_FLOAT_ARRAY, - ArrayUtils.subarray(array, 33, 4)); - - assertTrue("normal start, end overshoot", - ArrayUtils.isEquals(rightSubarray, - ArrayUtils.subarray(array, 2, 33))); - - assertTrue("start undershoot, end overshoot", - ArrayUtils.isEquals(array, - ArrayUtils.subarray(array, -2, 12))); + assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input"); + assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_FLOAT_ARRAY, 1, 2), + "empty array"); + assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end"); + assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end"); + assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), + "start undershoot, normal end"); + assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 33, 4),"start overshoot, any end"); + assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), + "normal start, end overshoot"); + assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot"); // empty-return tests - assertSame("empty array, object test", - ArrayUtils.EMPTY_FLOAT_ARRAY, - ArrayUtils.subarray(ArrayUtils.EMPTY_FLOAT_ARRAY, 1, 2)); - - assertSame("start > end, object test", - ArrayUtils.EMPTY_FLOAT_ARRAY, - ArrayUtils.subarray(array, 4, 1)); - - assertSame("start == end, object test", - ArrayUtils.EMPTY_FLOAT_ARRAY, - ArrayUtils.subarray(array, 3, 3)); - - assertSame("start overshoot, any end, object test", - ArrayUtils.EMPTY_FLOAT_ARRAY, - ArrayUtils.subarray(array, 8733, 4)); + assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_FLOAT_ARRAY, 1, 2), + "empty array, object test"); + assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test"); + assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test"); + assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 8733, 4), + "start overshoot, any end, object test"); // array type tests - assertSame("float type", float.class, - ArrayUtils.subarray(array, 2, 4).getClass().getComponentType()); - + assertSame(float.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "float type"); } @Test @@ -1363,74 +1118,36 @@ public class ArrayUtilsTest { final boolean[] midSubarray = {true, false, true, false}; final boolean[] rightSubarray = {false, true, false, true}; + assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end"); + assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end"); + assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end"); + assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), + "mid start, length end"); - assertTrue("0 start, mid end", - ArrayUtils.isEquals(leftSubarray, - ArrayUtils.subarray(array, 0, 4))); - - assertTrue("0 start, length end", - ArrayUtils.isEquals(array, - ArrayUtils.subarray(array, 0, array.length))); - - assertTrue("mid start, mid end", - ArrayUtils.isEquals(midSubarray, - ArrayUtils.subarray(array, 1, 5))); - - assertTrue("mid start, length end", - ArrayUtils.isEquals(rightSubarray, - ArrayUtils.subarray(array, 2, array.length))); - - - assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3)); - - assertEquals("empty array", ArrayUtils.EMPTY_BOOLEAN_ARRAY, - ArrayUtils.subarray(ArrayUtils.EMPTY_BOOLEAN_ARRAY, 1, 2)); - - assertEquals("start > end", ArrayUtils.EMPTY_BOOLEAN_ARRAY, - ArrayUtils.subarray(array, 4, 2)); - - assertEquals("start == end", ArrayUtils.EMPTY_BOOLEAN_ARRAY, - ArrayUtils.subarray(array, 3, 3)); - - assertTrue("start undershoot, normal end", - ArrayUtils.isEquals(leftSubarray, - ArrayUtils.subarray(array, -2, 4))); - - assertEquals("start overshoot, any end", - ArrayUtils.EMPTY_BOOLEAN_ARRAY, - ArrayUtils.subarray(array, 33, 4)); - - assertTrue("normal start, end overshoot", - ArrayUtils.isEquals(rightSubarray, - ArrayUtils.subarray(array, 2, 33))); - - assertTrue("start undershoot, end overshoot", - ArrayUtils.isEquals(array, - ArrayUtils.subarray(array, -2, 12))); + assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input"); + assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_BOOLEAN_ARRAY, 1, 2), + "empty array"); + assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end"); + assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end"); + assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), + "start undershoot, normal end"); + assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end"); + assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), + "normal start, end overshoot"); + assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot"); // empty-return tests - assertSame("empty array, object test", - ArrayUtils.EMPTY_BOOLEAN_ARRAY, - ArrayUtils.subarray(ArrayUtils.EMPTY_BOOLEAN_ARRAY, 1, 2)); - - assertSame("start > end, object test", - ArrayUtils.EMPTY_BOOLEAN_ARRAY, - ArrayUtils.subarray(array, 4, 1)); - - assertSame("start == end, object test", - ArrayUtils.EMPTY_BOOLEAN_ARRAY, - ArrayUtils.subarray(array, 3, 3)); - - assertSame("start overshoot, any end, object test", - ArrayUtils.EMPTY_BOOLEAN_ARRAY, - ArrayUtils.subarray(array, 8733, 4)); + assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_BOOLEAN_ARRAY, 1, 2), + "empty array, object test"); + assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test"); + assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test"); + assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 8733, 4), + "start overshoot, any end, object test"); // array type tests - assertSame("boolean type", boolean.class, - ArrayUtils.subarray(array, 2, 4).getClass().getComponentType()); - + assertSame(boolean.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "boolean type"); } //----------------------------------------------------------------------- @@ -1805,11 +1522,14 @@ public class ArrayUtilsTest { @Test public void testReverseDouble() { + // TODO: JUnit Jupiter 5.3.1 doesn't support delta=0. + // This should be replaced when it is supported in JUnit Jupiter 5.4. + // See https://github.com/junit-team/junit5/pull/1613 for details. double[] array = new double[]{0.3d, 0.4d, 0.5d}; ArrayUtils.reverse(array); - assertEquals(array[0], 0.5d, 0.0d); - assertEquals(array[1], 0.4d, 0.0d); - assertEquals(array[2], 0.3d, 0.0d); + assertTrue(array[0] == 0.5d); + assertTrue(array[1] == 0.4d); + assertTrue(array[2] == 0.3d); array = null; ArrayUtils.reverse(array); @@ -1818,11 +1538,14 @@ public class ArrayUtilsTest { @Test public void testReverseFloat() { + // TODO: JUnit Jupiter 5.3.1 doesn't support delta=0. + // This should be replaced when it is supported in JUnit Jupiter 5.4. + // See https://github.com/junit-team/junit5/pull/1613 for details. float[] array = new float[]{0.3f, 0.4f, 0.5f}; ArrayUtils.reverse(array); - assertEquals(array[0], 0.5f, 0.0f); - assertEquals(array[1], 0.4f, 0.0f); - assertEquals(array[2], 0.3f, 0.0f); + assertTrue(array[0] == 0.5f); + assertTrue(array[1] == 0.4f); + assertTrue(array[2] == 0.3f); array = null; ArrayUtils.reverse(array); @@ -1940,30 +1663,33 @@ public class ArrayUtilsTest { @Test public void testReverseDoubleRange() { + // TODO: JUnit Jupiter 5.3.1 doesn't support delta=0. + // This should be replaced when it is supported in JUnit Jupiter 5.4. + // See https://github.com/junit-team/junit5/pull/1613 for details. double[] array = new double[]{1, 2, 3}; // The whole array ArrayUtils.reverse(array, 0, 3); - assertEquals(3, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(1, array[2], 0); + assertTrue(3 == array[0]); + assertTrue(2 == array[1]); + assertTrue(1 == array[2]); // a range array = new double[]{1, 2, 3}; ArrayUtils.reverse(array, 0, 2); - assertEquals(2, array[0], 0); - assertEquals(1, array[1], 0); - assertEquals(3, array[2], 0); + assertTrue(2 == array[0]); + assertTrue(1 == array[1]); + assertTrue(3 == array[2]); // a range with a negative start array = new double[]{1, 2, 3}; ArrayUtils.reverse(array, -1, 3); - assertEquals(3, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(1, array[2], 0); + assertTrue(3 == array[0]); + assertTrue(2 == array[1]); + assertTrue(1 == array[2]); // a range with a large stop index array = new double[]{1, 2, 3}; ArrayUtils.reverse(array, -1, array.length + 1000); - assertEquals(3, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(1, array[2], 0); + assertTrue(3 == array[0]); + assertTrue(2 == array[1]); + assertTrue(1 == array[2]); // null array = null; ArrayUtils.reverse(array, 0, 3); @@ -1972,30 +1698,33 @@ public class ArrayUtilsTest { @Test public void testReverseFloatRange() { + // TODO: JUnit Jupiter 5.3.1 doesn't support delta=0. + // This should be replaced when it is supported in JUnit Jupiter 5.4. + // See https://github.com/junit-team/junit5/pull/1613 for details. float[] array = new float[]{1, 2, 3}; // The whole array ArrayUtils.reverse(array, 0, 3); - assertEquals(3, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(1, array[2], 0); + assertTrue(3 == array[0]); + assertTrue(2 == array[1]); + assertTrue(1 == array[2]); // a range array = new float[]{1, 2, 3}; ArrayUtils.reverse(array, 0, 2); - assertEquals(2, array[0], 0); - assertEquals(1, array[1], 0); - assertEquals(3, array[2], 0); + assertTrue(2 == array[0]); + assertTrue(1 == array[1]); + assertTrue(3 == array[2]); // a range with a negative start array = new float[]{1, 2, 3}; ArrayUtils.reverse(array, -1, 3); - assertEquals(3, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(1, array[2], 0); + assertTrue(3 == array[0]); + assertTrue(2 == array[1]); + assertTrue(1 == array[2]); // a range with a large stop index array = new float[]{1, 2, 3}; ArrayUtils.reverse(array, -1, array.length + 1000); - assertEquals(3, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(1, array[2], 0); + assertTrue(3 == array[0]); + assertTrue(2 == array[1]); + assertTrue(1 == array[2]); // null array = null; ArrayUtils.reverse(array, 0, 3); @@ -2251,11 +1980,14 @@ public class ArrayUtilsTest { @Test public void testSwapFloat() { + // TODO: JUnit Jupiter 5.3.1 doesn't support delta=0. + // This should be replaced when it is supported in JUnit Jupiter 5.4. + // See https://github.com/junit-team/junit5/pull/1613 for details. final float[] array = new float[]{1, 2, 3}; ArrayUtils.swap(array, 0, 2); - assertEquals(3, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(1, array[2], 0); + assertTrue(3 == array[0]); + assertTrue(2 == array[1]); + assertTrue(1 == array[2]); } @Test @@ -2274,51 +2006,57 @@ public class ArrayUtilsTest { @Test public void testSwapFloatRange() { + // TODO: JUnit Jupiter 5.3.1 doesn't support delta=0. + // This should be replaced when it is supported in JUnit Jupiter 5.4. + // See https://github.com/junit-team/junit5/pull/1613 for details. float[] array = new float[]{1, 2, 3, 4}; ArrayUtils.swap(array, 0, 2, 2); - assertEquals(3, array[0], 0); - assertEquals(4, array[1], 0); - assertEquals(1, array[2], 0); - assertEquals(2, array[3], 0); + assertTrue(3 == array[0]); + assertTrue(4 == array[1]); + assertTrue(1 == array[2]); + assertTrue(2 == array[3]); array = new float[]{1, 2, 3}; ArrayUtils.swap(array, 0, 3); - assertEquals(1, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(3, array[2], 0); + assertTrue(1 == array[0]); + assertTrue(2 == array[1]); + assertTrue(3 == array[2]); array = new float[]{1, 2, 3}; ArrayUtils.swap(array, 0, 2, 2); - assertEquals(3, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(1, array[2], 0); + assertTrue(3 == array[0]); + assertTrue(2 == array[1]); + assertTrue(1 == array[2]); array = new float[]{1, 2, 3}; ArrayUtils.swap(array, -1, 2, 2); - assertEquals(3, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(1, array[2], 0); + assertTrue(3 == array[0]); + assertTrue(2 == array[1]); + assertTrue(1 == array[2]); array = new float[]{1, 2, 3}; ArrayUtils.swap(array, 0, -1, 2); - assertEquals(1, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(3, array[2], 0); + assertTrue(1 == array[0]); + assertTrue(2 == array[1]); + assertTrue(3 == array[2]); array = new float[]{1, 2, 3}; ArrayUtils.swap(array, -1, -1, 2); - assertEquals(1, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(3, array[2], 0); + assertTrue(1 == array[0]); + assertTrue(2 == array[1]); + assertTrue(3 == array[2]); } @Test public void testSwapDouble() { + // TODO: JUnit Jupiter 5.3.1 doesn't support delta=0. + // This should be replaced when it is supported in JUnit Jupiter 5.4. + // See https://github.com/junit-team/junit5/pull/1613 for details. final double[] array = new double[]{1, 2, 3}; ArrayUtils.swap(array, 0, 2); - assertEquals(3, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(1, array[2], 0); + assertTrue(3 == array[0]); + assertTrue(2 == array[1]); + assertTrue(1 == array[2]); } @Test @@ -2337,42 +2075,45 @@ public class ArrayUtilsTest { @Test public void testSwapDoubleRange() { + // TODO: JUnit Jupiter 5.3.1 doesn't support delta=0. + // This should be replaced when it is supported in JUnit Jupiter 5.4. + // See https://github.com/junit-team/junit5/pull/1613 for details. double[] array = new double[]{1, 2, 3, 4}; ArrayUtils.swap(array, 0, 2, 2); - assertEquals(3, array[0], 0); - assertEquals(4, array[1], 0); - assertEquals(1, array[2], 0); - assertEquals(2, array[3], 0); + assertTrue(3 == array[0]); + assertTrue(4 == array[1]); + assertTrue(1 == array[2]); + assertTrue(2 == array[3]); array = new double[]{1, 2, 3}; ArrayUtils.swap(array, 0, 3); - assertEquals(1, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(3, array[2], 0); + assertTrue(1 == array[0]); + assertTrue(2 == array[1]); + assertTrue(3 == array[2]); array = new double[]{1, 2, 3}; ArrayUtils.swap(array, 0, 2, 2); - assertEquals(3, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(1, array[2], 0); + assertTrue(3 == array[0]); + assertTrue(2 == array[1]); + assertTrue(1 == array[2]); array = new double[]{1, 2, 3}; ArrayUtils.swap(array, -1, 2, 2); - assertEquals(3, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(1, array[2], 0); + assertTrue(3 == array[0]); + assertTrue(2 == array[1]); + assertTrue(1 == array[2]); array = new double[]{1, 2, 3}; ArrayUtils.swap(array, 0, -1, 2); - assertEquals(1, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(3, array[2], 0); + assertTrue(1 == array[0]); + assertTrue(2 == array[1]); + assertTrue(3 == array[2]); array = new double[]{1, 2, 3}; ArrayUtils.swap(array, -1, -1, 2); - assertEquals(1, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(3, array[2], 0); + assertTrue(1 == array[0]); + assertTrue(2 == array[1]); + assertTrue(3 == array[2]); } @Test @@ -2720,54 +2461,63 @@ public class ArrayUtilsTest { //----------------------------------------------------------------------- @Test public void testShiftDouble() { + // TODO: JUnit Jupiter 5.3.1 doesn't support delta=0. + // This should be replaced when it is supported in JUnit Jupiter 5.4. + // See https://github.com/junit-team/junit5/pull/1613 for details. final double[] array = new double[]{1, 2, 3, 4}; ArrayUtils.shift(array, 1); - assertEquals(4, array[0], 0); - assertEquals(1, array[1], 0); - assertEquals(2, array[2], 0); - assertEquals(3, array[3], 0); + assertTrue(4 == array[0]); + assertTrue(1 == array[1]); + assertTrue(2 == array[2]); + assertTrue(3 == array[3]); ArrayUtils.shift(array, -1); - assertEquals(1, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(3, array[2], 0); - assertEquals(4, array[3], 0); + assertTrue(1 == array[0]); + assertTrue(2 == array[1]); + assertTrue(3 == array[2]); + assertTrue(4 == array[3]); ArrayUtils.shift(array, 5); - assertEquals(4, array[0], 0); - assertEquals(1, array[1], 0); - assertEquals(2, array[2], 0); - assertEquals(3, array[3], 0); + assertTrue(4 == array[0]); + assertTrue(1 == array[1]); + assertTrue(2 == array[2]); + assertTrue(3 == array[3]); ArrayUtils.shift(array, -3); - assertEquals(3, array[0], 0); - assertEquals(4, array[1], 0); - assertEquals(1, array[2], 0); - assertEquals(2, array[3], 0); + assertTrue(3 == array[0]); + assertTrue(4 == array[1]); + assertTrue(1 == array[2]); + assertTrue(2 == array[3]); } @Test public void testShiftRangeDouble() { + // TODO: JUnit Jupiter 5.3.1 doesn't support delta=0. + // This should be replaced when it is supported in JUnit Jupiter 5.4. + // See https://github.com/junit-team/junit5/pull/1613 for details. final double[] array = new double[]{1, 2, 3, 4, 5}; ArrayUtils.shift(array, 1, 3, 1); - assertEquals(1, array[0], 0); - assertEquals(3, array[1], 0); - assertEquals(2, array[2], 0); - assertEquals(4, array[3], 0); - assertEquals(5, array[4], 0); + assertTrue(1 == array[0]); + assertTrue(3 == array[1]); + assertTrue(2 == array[2]); + assertTrue(4 == array[3]); + assertTrue(5 == array[4]); ArrayUtils.shift(array, 1, 4, 2); - assertEquals(1, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(4, array[2], 0); - assertEquals(3, array[3], 0); - assertEquals(5, array[4], 0); + assertTrue(1 == array[0]); + assertTrue(2 == array[1]); + assertTrue(4 == array[2]); + assertTrue(3 == array[3]); + assertTrue(5 == array[4]); } @Test public void testShiftRangeNoElemDouble() { + // TODO: JUnit Jupiter 5.3.1 doesn't support delta=0. + // This should be replaced when it is supported in JUnit Jupiter 5.4. + // See https://github.com/junit-team/junit5/pull/1613 for details. final double[] array = new double[]{1, 2, 3, 4}; ArrayUtils.shift(array, 1, 1, 1); - assertEquals(1, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(3, array[2], 0); - assertEquals(4, array[3], 0); + assertTrue(1 == array[0]); + assertTrue(2 == array[1]); + assertTrue(3 == array[2]); + assertTrue(4 == array[3]); } @Test @@ -2787,69 +2537,81 @@ public class ArrayUtilsTest { @Test public void testShiftAllDouble() { + // TODO: JUnit Jupiter 5.3.1 doesn't support delta=0. + // This should be replaced when it is supported in JUnit Jupiter 5.4. + // See https://github.com/junit-team/junit5/pull/1613 for details. final double[] array = new double[]{1, 2, 3, 4}; ArrayUtils.shift(array, 4); - assertEquals(1, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(3, array[2], 0); - assertEquals(4, array[3], 0); + assertTrue(1 == array[0]); + assertTrue(2 == array[1]); + assertTrue(3 == array[2]); + assertTrue(4 == array[3]); ArrayUtils.shift(array, -4); - assertEquals(1, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(3, array[2], 0); - assertEquals(4, array[3], 0); + assertTrue(1 == array[0]); + assertTrue(2 == array[1]); + assertTrue(3 == array[2]); + assertTrue(4 == array[3]); } @Test public void testShiftFloat() { + // TODO: JUnit Jupiter 5.3.1 doesn't support delta=0. + // This should be replaced when it is supported in JUnit Jupiter 5.4. + // See https://github.com/junit-team/junit5/pull/1613 for details. final float[] array = new float[]{1, 2, 3, 4}; ArrayUtils.shift(array, 1); - assertEquals(4, array[0], 0); - assertEquals(1, array[1], 0); - assertEquals(2, array[2], 0); - assertEquals(3, array[3], 0); + assertTrue(4 == array[0]); + assertTrue(1 == array[1]); + assertTrue(2 == array[2]); + assertTrue(3 == array[3]); ArrayUtils.shift(array, -1); - assertEquals(1, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(3, array[2], 0); - assertEquals(4, array[3], 0); + assertTrue(1 == array[0]); + assertTrue(2 == array[1]); + assertTrue(3 == array[2]); + assertTrue(4 == array[3]); ArrayUtils.shift(array, 5); - assertEquals(4, array[0], 0); - assertEquals(1, array[1], 0); - assertEquals(2, array[2], 0); - assertEquals(3, array[3], 0); + assertTrue(4 == array[0]); + assertTrue(1 == array[1]); + assertTrue(2 == array[2]); + assertTrue(3 == array[3]); ArrayUtils.shift(array, -3); - assertEquals(3, array[0], 0); - assertEquals(4, array[1], 0); - assertEquals(1, array[2], 0); - assertEquals(2, array[3], 0); + assertTrue(3 == array[0]); + assertTrue(4 == array[1]); + assertTrue(1 == array[2]); + assertTrue(2 == array[3]); } @Test public void testShiftRangeFloat() { + // TODO: JUnit Jupiter 5.3.1 doesn't support delta=0. + // This should be replaced when it is supported in JUnit Jupiter 5.4. + // See https://github.com/junit-team/junit5/pull/1613 for details. final float[] array = new float[]{1, 2, 3, 4, 5}; ArrayUtils.shift(array, 1, 3, 1); - assertEquals(1, array[0], 0); - assertEquals(3, array[1], 0); - assertEquals(2, array[2], 0); - assertEquals(4, array[3], 0); - assertEquals(5, array[4], 0); + assertTrue(1 == array[0]); + assertTrue(3 == array[1]); + assertTrue(2 == array[2]); + assertTrue(4 == array[3]); + assertTrue(5 == array[4]); ArrayUtils.shift(array, 1, 4, 2); - assertEquals(1, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(4, array[2], 0); - assertEquals(3, array[3], 0); - assertEquals(5, array[4], 0); + assertTrue(1 == array[0]); + assertTrue(2 == array[1]); + assertTrue(4 == array[2]); + assertTrue(3 == array[3]); + assertTrue(5 == array[4]); } @Test public void testShiftRangeNoElemFloat() { + // TODO: JUnit Jupiter 5.3.1 doesn't support delta=0. + // This should be replaced when it is supported in JUnit Jupiter 5.4. + // See https://github.com/junit-team/junit5/pull/1613 for details. final float[] array = new float[]{1, 2, 3, 4}; ArrayUtils.shift(array, 1, 1, 1); - assertEquals(1, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(3, array[2], 0); - assertEquals(4, array[3], 0); + assertTrue(1 == array[0]); + assertTrue(2 == array[1]); + assertTrue(3 == array[2]); + assertTrue(4 == array[3]); } @Test @@ -2869,17 +2631,20 @@ public class ArrayUtilsTest { @Test public void testShiftAllFloat() { + // TODO: JUnit Jupiter 5.3.1 doesn't support delta=0. + // This should be replaced when it is supported in JUnit Jupiter 5.4. + // See https://github.com/junit-team/junit5/pull/1613 for details. final float[] array = new float[]{1, 2, 3, 4}; ArrayUtils.shift(array, 4); - assertEquals(1, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(3, array[2], 0); - assertEquals(4, array[3], 0); + assertTrue(1 == array[0]); + assertTrue(2== array[1]); + assertTrue(3 == array[2]); + assertTrue(4 == array[3]); ArrayUtils.shift(array, -4); - assertEquals(1, array[0], 0); - assertEquals(2, array[1], 0); - assertEquals(3, array[2], 0); - assertEquals(4, array[3], 0); + assertTrue(1 == array[0]); + assertTrue(2== array[1]); + assertTrue(3 == array[2]); + assertTrue(4 == array[3]); } @Test @@ -4844,9 +4609,9 @@ public class ArrayUtilsTest { assertFalse(ArrayUtils.isSorted(array, c)); } - @Test(expected = IllegalArgumentException.class) - public void testIsSortedNullComparator() throws Exception { - ArrayUtils.isSorted(null, null); + @Test + public void testIsSortedNullComparator() { + assertThrows(IllegalArgumentException.class, () -> ArrayUtils.isSorted(null, null)); } @Test @@ -5014,7 +4779,7 @@ public class ArrayUtilsTest { ArrayUtils.shuffle(array1, new Random(SEED)); assertFalse(Arrays.equals(array1, array2)); for (final String element : array2) { - assertTrue("Element " + element + " not found", ArrayUtils.contains(array1, element)); + assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found"); } } @@ -5036,7 +4801,7 @@ public class ArrayUtilsTest { ArrayUtils.shuffle(array1, new Random(SEED)); assertFalse(Arrays.equals(array1, array2)); for (final byte element : array2) { - assertTrue("Element " + element + " not found", ArrayUtils.contains(array1, element)); + assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found"); } } @@ -5048,7 +4813,7 @@ public class ArrayUtilsTest { ArrayUtils.shuffle(array1, new Random(SEED)); assertFalse(Arrays.equals(array1, array2)); for (final char element : array2) { - assertTrue("Element " + element + " not found", ArrayUtils.contains(array1, element)); + assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found"); } } @@ -5060,7 +4825,7 @@ public class ArrayUtilsTest { ArrayUtils.shuffle(array1, new Random(SEED)); assertFalse(Arrays.equals(array1, array2)); for (final short element : array2) { - assertTrue("Element " + element + " not found", ArrayUtils.contains(array1, element)); + assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found"); } } @@ -5072,7 +4837,7 @@ public class ArrayUtilsTest { ArrayUtils.shuffle(array1, new Random(SEED)); assertFalse(Arrays.equals(array1, array2)); for (final int element : array2) { - assertTrue("Element " + element + " not found", ArrayUtils.contains(array1, element)); + assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found"); } } @@ -5084,7 +4849,7 @@ public class ArrayUtilsTest { ArrayUtils.shuffle(array1, new Random(SEED)); assertFalse(Arrays.equals(array1, array2)); for (final long element : array2) { - assertTrue("Element " + element + " not found", ArrayUtils.contains(array1, element)); + assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found"); } } @@ -5096,7 +4861,7 @@ public class ArrayUtilsTest { ArrayUtils.shuffle(array1, new Random(SEED)); assertFalse(Arrays.equals(array1, array2)); for (final float element : array2) { - assertTrue("Element " + element + " not found", ArrayUtils.contains(array1, element)); + assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found"); } } @@ -5108,7 +4873,7 @@ public class ArrayUtilsTest { ArrayUtils.shuffle(array1, new Random(SEED)); assertFalse(Arrays.equals(array1, array2)); for (final double element : array2) { - assertTrue("Element " + element + " not found", ArrayUtils.contains(array1, element)); + assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found"); } } diff --git a/src/test/java/org/apache/commons/lang3/BitFieldTest.java b/src/test/java/org/apache/commons/lang3/BitFieldTest.java index b621c89c6..b99e2b040 100644 --- a/src/test/java/org/apache/commons/lang3/BitFieldTest.java +++ b/src/test/java/org/apache/commons/lang3/BitFieldTest.java @@ -16,11 +16,11 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Class to test BitField functionality diff --git a/src/test/java/org/apache/commons/lang3/BooleanUtilsTest.java b/src/test/java/org/apache/commons/lang3/BooleanUtilsTest.java index 4fd3ad841..bea660d5d 100644 --- a/src/test/java/org/apache/commons/lang3/BooleanUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/BooleanUtilsTest.java @@ -16,17 +16,18 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.lang.reflect.Constructor; import java.lang.reflect.Modifier; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Unit tests {@link org.apache.commons.lang3.BooleanUtils}. @@ -131,9 +132,9 @@ public class BooleanUtilsTest { assertFalse(BooleanUtils.toBoolean(7, 6, 7)); } - @Test(expected = IllegalArgumentException.class) + @Test public void test_toBoolean_int_int_int_noMatch() { - BooleanUtils.toBoolean(8, 6, 7); + assertThrows(IllegalArgumentException.class, () -> BooleanUtils.toBoolean(8, 6, 7)); } @Test @@ -148,14 +149,16 @@ public class BooleanUtilsTest { assertFalse(BooleanUtils.toBoolean(Integer.valueOf(7), six, seven)); } - @Test(expected = IllegalArgumentException.class) + @Test public void test_toBoolean_Integer_Integer_Integer_nullValue() { - BooleanUtils.toBoolean(null, Integer.valueOf(6), Integer.valueOf(7)); + assertThrows(IllegalArgumentException.class, + () -> BooleanUtils.toBoolean(null, Integer.valueOf(6), Integer.valueOf(7))); } - @Test(expected = IllegalArgumentException.class) + @Test public void test_toBoolean_Integer_Integer_Integer_noMatch() { - BooleanUtils.toBoolean(Integer.valueOf(8), Integer.valueOf(6), Integer.valueOf(7)); + assertThrows(IllegalArgumentException.class, + () -> BooleanUtils.toBoolean(Integer.valueOf(8), Integer.valueOf(6), Integer.valueOf(7))); } //----------------------------------------------------------------------- @@ -166,9 +169,9 @@ public class BooleanUtilsTest { assertNull(BooleanUtils.toBooleanObject(8, 6, 7, 8)); } - @Test(expected = IllegalArgumentException.class) + @Test public void test_toBooleanObject_int_int_int_noMatch() { - BooleanUtils.toBooleanObject(9, 6, 7, 8); + assertThrows(IllegalArgumentException.class, () -> BooleanUtils.toBooleanObject(9, 6, 7, 8)); } @Test @@ -186,14 +189,16 @@ public class BooleanUtilsTest { assertNull(BooleanUtils.toBooleanObject(Integer.valueOf(8), six, seven, eight)); } - @Test(expected = IllegalArgumentException.class) + @Test public void test_toBooleanObject_Integer_Integer_Integer_Integer_nullValue() { - BooleanUtils.toBooleanObject(null, Integer.valueOf(6), Integer.valueOf(7), Integer.valueOf(8)); + assertThrows(IllegalArgumentException.class, + () -> BooleanUtils.toBooleanObject(null, Integer.valueOf(6), Integer.valueOf(7), Integer.valueOf(8))); } - @Test(expected = IllegalArgumentException.class) + @Test public void test_toBooleanObject_Integer_Integer_Integer_Integer_noMatch() { - BooleanUtils.toBooleanObject(Integer.valueOf(9), Integer.valueOf(6), Integer.valueOf(7), Integer.valueOf(8)); + assertThrows(IllegalArgumentException.class, + () -> BooleanUtils.toBooleanObject(Integer.valueOf(9), Integer.valueOf(6), Integer.valueOf(7), Integer.valueOf(8))); } //----------------------------------------------------------------------- @@ -298,14 +303,14 @@ public class BooleanUtilsTest { assertNull(BooleanUtils.toBooleanObject("U", "Y", "N", "U")); } - @Test(expected = IllegalArgumentException.class) + @Test public void test_toBooleanObject_String_String_String_String_nullValue() { - BooleanUtils.toBooleanObject(null, "Y", "N", "U"); + assertThrows(IllegalArgumentException.class, () -> BooleanUtils.toBooleanObject(null, "Y", "N", "U")); } - @Test(expected = IllegalArgumentException.class) + @Test public void test_toBooleanObject_String_String_String_String_noMatch() { - BooleanUtils.toBooleanObject("X", "Y", "N", "U"); + assertThrows(IllegalArgumentException.class, () -> BooleanUtils.toBooleanObject("X", "Y", "N", "U")); } //----------------------------------------------------------------------- @@ -369,14 +374,14 @@ public class BooleanUtilsTest { assertTrue(BooleanUtils.toBoolean("Y", new String("Y"), new String("Y"))); } - @Test(expected = IllegalArgumentException.class) + @Test public void test_toBoolean_String_String_String_nullValue() { - BooleanUtils.toBoolean(null, "Y", "N"); + assertThrows(IllegalArgumentException.class, () -> BooleanUtils.toBoolean(null, "Y", "N")); } - @Test(expected = IllegalArgumentException.class) + @Test public void test_toBoolean_String_String_String_noMatch() { - BooleanUtils.toBoolean("X", "Y", "N"); + assertThrows(IllegalArgumentException.class, () -> BooleanUtils.toBoolean("X", "Y", "N")); } //----------------------------------------------------------------------- @@ -435,575 +440,570 @@ public class BooleanUtilsTest { // testXor // ----------------------------------------------------------------------- - @Test(expected = IllegalArgumentException.class) + @Test public void testXor_primitive_nullInput() { - BooleanUtils.xor((boolean[]) null); + assertThrows(IllegalArgumentException.class, () -> BooleanUtils.xor((boolean[]) null)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testXor_primitive_emptyInput() { - BooleanUtils.xor(new boolean[] {}); + assertThrows(IllegalArgumentException.class, () -> BooleanUtils.xor(new boolean[] {})); } @Test public void testXor_primitive_validInput_2items() { assertEquals( - "true ^ true", - true ^ true , - BooleanUtils.xor(new boolean[] { true, true })); + true ^ true, + BooleanUtils.xor(new boolean[] { true, true }), + "true ^ true"); assertEquals( - "false ^ false", - false ^ false, - BooleanUtils.xor(new boolean[] { false, false })); + false ^ false, + BooleanUtils.xor(new boolean[] { false, false }), + "false ^ false"); assertEquals( - "true ^ false", - true ^ false, - BooleanUtils.xor(new boolean[] { true, false })); + true ^ false, + BooleanUtils.xor(new boolean[] { true, false }), + "true ^ false"); assertEquals( - "false ^ true", - false ^ true, - BooleanUtils.xor(new boolean[] { false, true })); + false ^ true, + BooleanUtils.xor(new boolean[] { false, true }), + "false ^ true"); } @Test public void testXor_primitive_validInput_3items() { assertEquals( - "false ^ false ^ false", - false ^ false ^ false, - BooleanUtils.xor(new boolean[] { false, false, false })); + false ^ false ^ false, + BooleanUtils.xor(new boolean[] { false, false, false }), + "false ^ false ^ false"); assertEquals( - "false ^ false ^ true", - false ^ false ^ true, - BooleanUtils.xor(new boolean[] { false, false, true })); + false ^ false ^ true, + BooleanUtils.xor(new boolean[] { false, false, true }), + "false ^ false ^ true"); assertEquals( - "false ^ true ^ false", - false ^ true ^ false, - BooleanUtils.xor(new boolean[] { false, true, false })); + false ^ true ^ false, + BooleanUtils.xor(new boolean[] { false, true, false }), + "false ^ true ^ false"); assertEquals( - "false ^ true ^ true", - false ^ true ^ true, - BooleanUtils.xor(new boolean[] { false, true, true })); + false ^ true ^ true, + BooleanUtils.xor(new boolean[] { false, true, true }), + "false ^ true ^ true"); assertEquals( - "true ^ false ^ false", - true ^ false ^ false, - BooleanUtils.xor(new boolean[] { true, false, false })); + true ^ false ^ false, + BooleanUtils.xor(new boolean[] { true, false, false }), + "true ^ false ^ false"); assertEquals( - "true ^ false ^ true", - true ^ false ^ true, - BooleanUtils.xor(new boolean[] { true, false, true })); + true ^ false ^ true, + BooleanUtils.xor(new boolean[] { true, false, true }), + "true ^ false ^ true"); assertEquals( - "true ^ true ^ false", - true ^ true ^ false, - BooleanUtils.xor(new boolean[] { true, true, false })); + true ^ true ^ false, + BooleanUtils.xor(new boolean[] { true, true, false }), + "true ^ true ^ false"); assertEquals( - "true ^ true ^ true", - true ^ true ^ true, - BooleanUtils.xor(new boolean[] { true, true, true })); + true ^ true ^ true, + BooleanUtils.xor(new boolean[] { true, true, true }), + "true ^ true ^ true"); } - @Test(expected = IllegalArgumentException.class) + @Test public void testXor_object_nullInput() { - BooleanUtils.xor((Boolean[]) null); + assertThrows(IllegalArgumentException.class, () -> BooleanUtils.xor((Boolean[]) null)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testXor_object_emptyInput() { - BooleanUtils.xor(new Boolean[] {}); + assertThrows(IllegalArgumentException.class, () -> BooleanUtils.xor(new Boolean[] {})); } - @Test(expected = IllegalArgumentException.class) + @Test public void testXor_object_nullElementInput() { - BooleanUtils.xor(new Boolean[] {null}); + assertThrows(IllegalArgumentException.class, () -> BooleanUtils.xor(new Boolean[] {null})); } @Test public void testXor_object_validInput_2items() { assertEquals( - "false ^ false", - false ^ false, - BooleanUtils - .xor(new Boolean[] { Boolean.FALSE, Boolean.FALSE }) - .booleanValue()); + false ^ false, + BooleanUtils.xor(new Boolean[] { Boolean.FALSE, Boolean.FALSE }).booleanValue(), + "false ^ false"); assertEquals( - "false ^ true", - false ^ true, - BooleanUtils - .xor(new Boolean[] { Boolean.FALSE, Boolean.TRUE }) - .booleanValue()); + false ^ true, + BooleanUtils.xor(new Boolean[] { Boolean.FALSE, Boolean.TRUE }).booleanValue(), + "false ^ true"); assertEquals( - "true ^ false", - true ^ false, - BooleanUtils - .xor(new Boolean[] { Boolean.TRUE, Boolean.FALSE }) - .booleanValue()); + true ^ false, + BooleanUtils.xor(new Boolean[] { Boolean.TRUE, Boolean.FALSE }).booleanValue(), + "true ^ false"); assertEquals( - "true ^ true", - true ^ true, - BooleanUtils - .xor(new Boolean[] { Boolean.TRUE, Boolean.TRUE }) - .booleanValue()); + true ^ true, + BooleanUtils.xor(new Boolean[] { Boolean.TRUE, Boolean.TRUE }).booleanValue(), + "true ^ true"); } @Test public void testXor_object_validInput_3items() { assertEquals( - "false ^ false ^ false", false ^ false ^ false, BooleanUtils.xor( - new Boolean[] { + new Boolean[] { + Boolean.FALSE, + Boolean.FALSE, + Boolean.FALSE }) + .booleanValue(), + "false ^ false ^ false"); + + assertEquals( + false ^ false ^ true, + BooleanUtils + .xor( + new Boolean[] { Boolean.FALSE, Boolean.FALSE, + Boolean.TRUE }) + .booleanValue(), + "false ^ false ^ true"); + + assertEquals( + false ^ true ^ false, + BooleanUtils + .xor( + new Boolean[] { + Boolean.FALSE, + Boolean.TRUE, + Boolean.FALSE }) + .booleanValue(), + "false ^ true ^ false"); + + assertEquals( + true ^ false ^ false, + BooleanUtils + .xor( + new Boolean[] { + Boolean.TRUE, + Boolean.FALSE, Boolean.FALSE }) - .booleanValue()); + .booleanValue(), + "true ^ false ^ false"); assertEquals( - "false ^ false ^ true", - false ^ false ^ true, - BooleanUtils - .xor( - new Boolean[] { - Boolean.FALSE, - Boolean.FALSE, - Boolean.TRUE }) - .booleanValue()); - - assertEquals( - "false ^ true ^ false", - false ^ true ^ false, - BooleanUtils - .xor( - new Boolean[] { - Boolean.FALSE, - Boolean.TRUE, - Boolean.FALSE }) - .booleanValue()); - - assertEquals( - "true ^ false ^ false", - true ^ false ^ false, - BooleanUtils - .xor( - new Boolean[] { - Boolean.TRUE, - Boolean.FALSE, - Boolean.FALSE }) - .booleanValue()); - - assertEquals( - "true ^ false ^ true", true ^ false ^ true, + BooleanUtils.xor( + new Boolean[] { + Boolean.TRUE, + Boolean.FALSE, + Boolean.TRUE }) + .booleanValue(), + "true ^ false ^ true"); + + assertEquals( + true ^ true ^ false, + BooleanUtils.xor( + new Boolean[] { + Boolean.TRUE, + Boolean.TRUE, + Boolean.FALSE }) + .booleanValue(), + "true ^ true ^ false"); + + assertEquals( + false ^ true ^ true, + BooleanUtils.xor( + new Boolean[] { + Boolean.FALSE, + Boolean.TRUE, + Boolean.TRUE }) + .booleanValue(), + "false ^ true ^ true"); + + assertEquals( + true ^ true ^ true, BooleanUtils.xor( new Boolean[] { Boolean.TRUE, - Boolean.FALSE, + Boolean.TRUE, Boolean.TRUE }) - .booleanValue()); - - assertEquals( - "true ^ true ^ false", - true ^ true ^ false, - BooleanUtils.xor( - new Boolean[] { - Boolean.TRUE, - Boolean.TRUE, - Boolean.FALSE }) - .booleanValue()); - - assertEquals( - "false ^ true ^ true", - false ^ true ^ true, - BooleanUtils.xor( - new Boolean[] { - Boolean.FALSE, - Boolean.TRUE, - Boolean.TRUE }) - .booleanValue()); - - assertEquals( - "true ^ true ^ true", - true ^ true ^ true, - BooleanUtils - .xor(new Boolean[] { Boolean.TRUE, Boolean.TRUE, Boolean.TRUE }) - .booleanValue()); + .booleanValue(), + "true ^ true ^ true"); } // testAnd // ----------------------------------------------------------------------- - @Test(expected = IllegalArgumentException.class) + @Test public void testAnd_primitive_nullInput() { - BooleanUtils.and((boolean[]) null); + assertThrows(IllegalArgumentException.class, () -> BooleanUtils.and((boolean[]) null)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testAnd_primitive_emptyInput() { - BooleanUtils.and(new boolean[] {}); + assertThrows(IllegalArgumentException.class, () -> BooleanUtils.and(new boolean[] {})); } @Test public void testAnd_primitive_validInput_2items() { assertTrue( - "False result for (true, true)", - BooleanUtils.and(new boolean[] { true, true })); + BooleanUtils.and(new boolean[] { true, true }), + "False result for (true, true)"); assertTrue( - "True result for (false, false)", - ! BooleanUtils.and(new boolean[] { false, false })); + ! BooleanUtils.and(new boolean[] { false, false }), + "True result for (false, false)"); assertTrue( - "True result for (true, false)", - ! BooleanUtils.and(new boolean[] { true, false })); + ! BooleanUtils.and(new boolean[] { true, false }), + "True result for (true, false)"); assertTrue( - "True result for (false, true)", - ! BooleanUtils.and(new boolean[] { false, true })); + ! BooleanUtils.and(new boolean[] { false, true }), + "True result for (false, true)"); } @Test public void testAnd_primitive_validInput_3items() { assertTrue( - "True result for (false, false, true)", - ! BooleanUtils.and(new boolean[] { false, false, true })); + ! BooleanUtils.and(new boolean[] { false, false, true }), + "True result for (false, false, true)"); assertTrue( - "True result for (false, true, false)", - ! BooleanUtils.and(new boolean[] { false, true, false })); + ! BooleanUtils.and(new boolean[] { false, true, false }), + "True result for (false, true, false)"); assertTrue( - "True result for (true, false, false)", - ! BooleanUtils.and(new boolean[] { true, false, false })); + ! BooleanUtils.and(new boolean[] { true, false, false }), + "True result for (true, false, false)"); assertTrue( - "False result for (true, true, true)", - BooleanUtils.and(new boolean[] { true, true, true })); + BooleanUtils.and(new boolean[] { true, true, true }), + "False result for (true, true, true)"); assertTrue( - "True result for (false, false)", - ! BooleanUtils.and(new boolean[] { false, false, false })); + ! BooleanUtils.and(new boolean[] { false, false, false }), + "True result for (false, false)"); assertTrue( - "True result for (true, true, false)", - ! BooleanUtils.and(new boolean[] { true, true, false })); + ! BooleanUtils.and(new boolean[] { true, true, false }), + "True result for (true, true, false)"); assertTrue( - "True result for (true, false, true)", - ! BooleanUtils.and(new boolean[] { true, false, true })); + ! BooleanUtils.and(new boolean[] { true, false, true }), + "True result for (true, false, true)"); assertTrue( - "True result for (false, true, true)", - ! BooleanUtils.and(new boolean[] { false, true, true })); + ! BooleanUtils.and(new boolean[] { false, true, true }), + "True result for (false, true, true)"); } - @Test(expected = IllegalArgumentException.class) + @Test public void testAnd_object_nullInput() { - BooleanUtils.and((Boolean[]) null); + assertThrows(IllegalArgumentException.class, () -> BooleanUtils.and((Boolean[]) null)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testAnd_object_emptyInput() { - BooleanUtils.and(new Boolean[] {}); + assertThrows(IllegalArgumentException.class, () -> BooleanUtils.and(new Boolean[] {})); } - @Test(expected = IllegalArgumentException.class) + @Test public void testAnd_object_nullElementInput() { - BooleanUtils.and(new Boolean[] {null}); + assertThrows(IllegalArgumentException.class, () -> BooleanUtils.and(new Boolean[] {null})); } @Test public void testAnd_object_validInput_2items() { assertTrue( - "False result for (true, true)", - BooleanUtils - .and(new Boolean[] { Boolean.TRUE, Boolean.TRUE }) - .booleanValue()); + BooleanUtils + .and(new Boolean[] { Boolean.TRUE, Boolean.TRUE }) + .booleanValue(), + "False result for (true, true)"); assertTrue( - "True result for (false, false)", - ! BooleanUtils - .and(new Boolean[] { Boolean.FALSE, Boolean.FALSE }) - .booleanValue()); + ! BooleanUtils + .and(new Boolean[] { Boolean.FALSE, Boolean.FALSE }) + .booleanValue(), + "True result for (false, false)"); assertTrue( - "True result for (true, false)", - ! BooleanUtils - .and(new Boolean[] { Boolean.TRUE, Boolean.FALSE }) - .booleanValue()); + ! BooleanUtils + .and(new Boolean[] { Boolean.TRUE, Boolean.FALSE }) + .booleanValue(), + "True result for (true, false)"); assertTrue( - "True result for (false, true)", - ! BooleanUtils - .and(new Boolean[] { Boolean.FALSE, Boolean.TRUE }) - .booleanValue()); + ! BooleanUtils + .and(new Boolean[] { Boolean.FALSE, Boolean.TRUE }) + .booleanValue(), + "True result for (false, true)"); } @Test public void testAnd_object_validInput_3items() { assertTrue( - "True result for (false, false, true)", - ! BooleanUtils - .and( - new Boolean[] { - Boolean.FALSE, - Boolean.FALSE, - Boolean.TRUE }) - .booleanValue()); + ! BooleanUtils + .and( + new Boolean[] { + Boolean.FALSE, + Boolean.FALSE, + Boolean.TRUE }) + .booleanValue(), + "True result for (false, false, true)"); assertTrue( - "True result for (false, true, false)", - ! BooleanUtils - .and( - new Boolean[] { - Boolean.FALSE, - Boolean.TRUE, - Boolean.FALSE }) - .booleanValue()); + ! BooleanUtils + .and( + new Boolean[] { + Boolean.FALSE, + Boolean.TRUE, + Boolean.FALSE }) + .booleanValue(), + "True result for (false, true, false)"); assertTrue( - "True result for (true, false, false)", - ! BooleanUtils - .and( - new Boolean[] { - Boolean.TRUE, - Boolean.FALSE, - Boolean.FALSE }) - .booleanValue()); + ! BooleanUtils + .and( + new Boolean[] { + Boolean.TRUE, + Boolean.FALSE, + Boolean.FALSE }) + .booleanValue(), + "True result for (true, false, false)"); assertTrue( - "False result for (true, true, true)", - BooleanUtils - .and(new Boolean[] { Boolean.TRUE, Boolean.TRUE, Boolean.TRUE }) - .booleanValue()); + BooleanUtils + .and(new Boolean[] { Boolean.TRUE, Boolean.TRUE, Boolean.TRUE }) + .booleanValue(), + "False result for (true, true, true)"); assertTrue( - "True result for (false, false)", - ! BooleanUtils.and( - new Boolean[] { - Boolean.FALSE, - Boolean.FALSE, - Boolean.FALSE }) - .booleanValue()); + ! BooleanUtils.and( + new Boolean[] { + Boolean.FALSE, + Boolean.FALSE, + Boolean.FALSE }) + .booleanValue(), + "True result for (false, false)"); assertTrue( - "True result for (true, true, false)", - ! BooleanUtils.and( - new Boolean[] { - Boolean.TRUE, - Boolean.TRUE, - Boolean.FALSE }) - .booleanValue()); + ! BooleanUtils.and( + new Boolean[] { + Boolean.TRUE, + Boolean.TRUE, + Boolean.FALSE }) + .booleanValue(), + "True result for (true, true, false)"); assertTrue( - "True result for (true, false, true)", - ! BooleanUtils.and( - new Boolean[] { - Boolean.TRUE, - Boolean.FALSE, - Boolean.TRUE }) - .booleanValue()); + ! BooleanUtils.and( + new Boolean[] { + Boolean.TRUE, + Boolean.FALSE, + Boolean.TRUE }) + .booleanValue(), + "True result for (true, false, true)"); assertTrue( - "True result for (false, true, true)", - ! BooleanUtils.and( - new Boolean[] { - Boolean.FALSE, - Boolean.TRUE, - Boolean.TRUE }) - .booleanValue()); + ! BooleanUtils.and( + new Boolean[] { + Boolean.FALSE, + Boolean.TRUE, + Boolean.TRUE }) + .booleanValue(), + "True result for (false, true, true)"); } // testOr // ----------------------------------------------------------------------- - @Test(expected = IllegalArgumentException.class) + @Test public void testOr_primitive_nullInput() { - BooleanUtils.or((boolean[]) null); + assertThrows(IllegalArgumentException.class, () -> BooleanUtils.or((boolean[]) null)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testOr_primitive_emptyInput() { - BooleanUtils.or(new boolean[] {}); + assertThrows(IllegalArgumentException.class, () -> BooleanUtils.or(new boolean[] {})); } @Test public void testOr_primitive_validInput_2items() { assertTrue( - "False result for (true, true)", - BooleanUtils.or(new boolean[] { true, true })); + BooleanUtils.or(new boolean[] { true, true }), + "False result for (true, true)"); assertTrue( - "True result for (false, false)", - ! BooleanUtils.or(new boolean[] { false, false })); + ! BooleanUtils.or(new boolean[] { false, false }), + "True result for (false, false)"); assertTrue( - "False result for (true, false)", - BooleanUtils.or(new boolean[] { true, false })); + BooleanUtils.or(new boolean[] { true, false }), + "False result for (true, false)"); assertTrue( - "False result for (false, true)", - BooleanUtils.or(new boolean[] { false, true })); + BooleanUtils.or(new boolean[] { false, true }), + "False result for (false, true)"); } @Test public void testOr_primitive_validInput_3items() { assertTrue( - "False result for (false, false, true)", - BooleanUtils.or(new boolean[] { false, false, true })); + BooleanUtils.or(new boolean[] { false, false, true }), + "False result for (false, false, true)"); assertTrue( - "False result for (false, true, false)", - BooleanUtils.or(new boolean[] { false, true, false })); + BooleanUtils.or(new boolean[] { false, true, false }), + "False result for (false, true, false)"); assertTrue( - "False result for (true, false, false)", - BooleanUtils.or(new boolean[] { true, false, false })); + BooleanUtils.or(new boolean[] { true, false, false }), + "False result for (true, false, false)"); assertTrue( - "False result for (true, true, true)", - BooleanUtils.or(new boolean[] { true, true, true })); + BooleanUtils.or(new boolean[] { true, true, true }), + "False result for (true, true, true)"); assertTrue( - "True result for (false, false)", - ! BooleanUtils.or(new boolean[] { false, false, false })); + ! BooleanUtils.or(new boolean[] { false, false, false }), + "True result for (false, false)"); assertTrue( - "False result for (true, true, false)", - BooleanUtils.or(new boolean[] { true, true, false })); + BooleanUtils.or(new boolean[] { true, true, false }), + "False result for (true, true, false)"); assertTrue( - "False result for (true, false, true)", - BooleanUtils.or(new boolean[] { true, false, true })); + BooleanUtils.or(new boolean[] { true, false, true }), + "False result for (true, false, true)"); assertTrue( - "False result for (false, true, true)", - BooleanUtils.or(new boolean[] { false, true, true })); + BooleanUtils.or(new boolean[] { false, true, true }), + "False result for (false, true, true)"); } - @Test(expected = IllegalArgumentException.class) + @Test public void testOr_object_nullInput() { - BooleanUtils.or((Boolean[]) null); + assertThrows(IllegalArgumentException.class, () -> BooleanUtils.or((Boolean[]) null)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testOr_object_emptyInput() { - BooleanUtils.or(new Boolean[] {}); + assertThrows(IllegalArgumentException.class, () -> BooleanUtils.or(new Boolean[] {})); } - @Test(expected = IllegalArgumentException.class) + @Test public void testOr_object_nullElementInput() { - BooleanUtils.or(new Boolean[] {null}); + assertThrows(IllegalArgumentException.class, () -> BooleanUtils.or(new Boolean[] {null})); } @Test public void testOr_object_validInput_2items() { assertTrue( - "False result for (true, true)", - BooleanUtils - .or(new Boolean[] { Boolean.TRUE, Boolean.TRUE }) - .booleanValue()); + BooleanUtils + .or(new Boolean[] { Boolean.TRUE, Boolean.TRUE }) + .booleanValue(), + "False result for (true, true)"); assertTrue( - "True result for (false, false)", - ! BooleanUtils - .or(new Boolean[] { Boolean.FALSE, Boolean.FALSE }) - .booleanValue()); + ! BooleanUtils + .or(new Boolean[] { Boolean.FALSE, Boolean.FALSE }) + .booleanValue(), + "True result for (false, false)"); assertTrue( - "False result for (true, false)", - BooleanUtils - .or(new Boolean[] { Boolean.TRUE, Boolean.FALSE }) - .booleanValue()); + BooleanUtils + .or(new Boolean[] { Boolean.TRUE, Boolean.FALSE }) + .booleanValue(), + "False result for (true, false)"); assertTrue( - "False result for (false, true)", - BooleanUtils - .or(new Boolean[] { Boolean.FALSE, Boolean.TRUE }) - .booleanValue()); + BooleanUtils + .or(new Boolean[] { Boolean.FALSE, Boolean.TRUE }) + .booleanValue(), + "False result for (false, true)"); } @Test public void testOr_object_validInput_3items() { assertTrue( - "False result for (false, false, true)", - BooleanUtils - .or( - new Boolean[] { - Boolean.FALSE, - Boolean.FALSE, - Boolean.TRUE }) - .booleanValue()); + BooleanUtils + .or( + new Boolean[] { + Boolean.FALSE, + Boolean.FALSE, + Boolean.TRUE }) + .booleanValue(), + "False result for (false, false, true)"); assertTrue( - "False result for (false, true, false)", - BooleanUtils - .or( - new Boolean[] { - Boolean.FALSE, - Boolean.TRUE, - Boolean.FALSE }) - .booleanValue()); + BooleanUtils + .or( + new Boolean[] { + Boolean.FALSE, + Boolean.TRUE, + Boolean.FALSE }) + .booleanValue(), + "False result for (false, true, false)"); assertTrue( - "False result for (true, false, false)", - BooleanUtils - .or( - new Boolean[] { - Boolean.TRUE, - Boolean.FALSE, - Boolean.FALSE }) - .booleanValue()); + BooleanUtils + .or( + new Boolean[] { + Boolean.TRUE, + Boolean.FALSE, + Boolean.FALSE }) + .booleanValue(), + "False result for (true, false, false)"); assertTrue( - "False result for (true, true, true)", - BooleanUtils - .or(new Boolean[] { Boolean.TRUE, Boolean.TRUE, Boolean.TRUE }) - .booleanValue()); + BooleanUtils + .or(new Boolean[] { Boolean.TRUE, Boolean.TRUE, Boolean.TRUE }) + .booleanValue(), + "False result for (true, true, true)"); assertTrue( - "True result for (false, false)", - ! BooleanUtils.or( - new Boolean[] { - Boolean.FALSE, - Boolean.FALSE, - Boolean.FALSE }) - .booleanValue()); + ! BooleanUtils.or( + new Boolean[] { + Boolean.FALSE, + Boolean.FALSE, + Boolean.FALSE }) + .booleanValue(), + "True result for (false, false)"); assertTrue( - "False result for (true, true, false)", - BooleanUtils.or( - new Boolean[] { - Boolean.TRUE, - Boolean.TRUE, - Boolean.FALSE }) - .booleanValue()); + BooleanUtils.or( + new Boolean[] { + Boolean.TRUE, + Boolean.TRUE, + Boolean.FALSE }) + .booleanValue(), + "False result for (true, true, false)"); assertTrue( - "False result for (true, false, true)", - BooleanUtils.or( - new Boolean[] { - Boolean.TRUE, - Boolean.FALSE, - Boolean.TRUE }) - .booleanValue()); + BooleanUtils.or( + new Boolean[] { + Boolean.TRUE, + Boolean.FALSE, + Boolean.TRUE }) + .booleanValue(), + "False result for (true, false, true)"); assertTrue( - "False result for (false, true, true)", - BooleanUtils.or( - new Boolean[] { - Boolean.FALSE, - Boolean.TRUE, - Boolean.TRUE }) - .booleanValue()); + BooleanUtils.or( + new Boolean[] { + Boolean.FALSE, + Boolean.TRUE, + Boolean.TRUE }) + .booleanValue(), + "False result for (false, true, true)"); } @Test diff --git a/src/test/java/org/apache/commons/lang3/CharEncodingTest.java b/src/test/java/org/apache/commons/lang3/CharEncodingTest.java index 5f7748ca3..b96a5d14d 100644 --- a/src/test/java/org/apache/commons/lang3/CharEncodingTest.java +++ b/src/test/java/org/apache/commons/lang3/CharEncodingTest.java @@ -17,11 +17,11 @@ package org.apache.commons.lang3; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.junit.Test; +import org.junit.jupiter.api.Test; import java.nio.charset.StandardCharsets; @@ -34,7 +34,7 @@ import java.nio.charset.StandardCharsets; public class CharEncodingTest { private void assertSupportedEncoding(final String name) { - assertTrue("Encoding should be supported: " + name, CharEncoding.isSupported(name)); + assertTrue(CharEncoding.isSupported(name), "Encoding should be supported: " + name); } /** diff --git a/src/test/java/org/apache/commons/lang3/CharRangeTest.java b/src/test/java/org/apache/commons/lang3/CharRangeTest.java index 54f2a8706..05afa6d9c 100644 --- a/src/test/java/org/apache/commons/lang3/CharRangeTest.java +++ b/src/test/java/org/apache/commons/lang3/CharRangeTest.java @@ -18,17 +18,18 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +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.lang.reflect.Modifier; import java.util.Iterator; import java.util.NoSuchElementException; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Unit tests {@link org.apache.commons.lang3.CharRange}. @@ -398,10 +399,10 @@ public class CharRangeTest { } //----------------------------------------------------------------------- - @Test(expected = UnsupportedOperationException.class) + @Test public void testIteratorRemove() { final CharRange a = CharRange.is('a'); final Iterator aIt = a.iterator(); - aIt.remove(); + assertThrows(UnsupportedOperationException.class, aIt::remove); } } diff --git a/src/test/java/org/apache/commons/lang3/CharSequenceUtilsTest.java b/src/test/java/org/apache/commons/lang3/CharSequenceUtilsTest.java index 4b03087d5..5b59f9eeb 100644 --- a/src/test/java/org/apache/commons/lang3/CharSequenceUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/CharSequenceUtilsTest.java @@ -16,18 +16,19 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +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.lang.reflect.Constructor; import java.lang.reflect.Modifier; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Tests CharSequenceUtils @@ -64,14 +65,14 @@ public class CharSequenceUtilsTest { assertEquals(StringUtils.EMPTY, CharSequenceUtils.subSequence("012", 3)); } - @Test(expected=IndexOutOfBoundsException.class) + @Test public void testSubSequenceNegativeStart() { - assertNull(CharSequenceUtils.subSequence(StringUtils.EMPTY, -1)); + assertThrows(IndexOutOfBoundsException.class, () -> CharSequenceUtils.subSequence(StringUtils.EMPTY, -1)); } - @Test(expected=IndexOutOfBoundsException.class) + @Test public void testSubSequenceTooLong() { - assertNull(CharSequenceUtils.subSequence(StringUtils.EMPTY, 1)); + assertThrows(IndexOutOfBoundsException.class, () -> CharSequenceUtils.subSequence(StringUtils.EMPTY, 1)); } static class TestData{ @@ -154,7 +155,7 @@ public class CharSequenceUtilsTest { } } else { final boolean stringCheck = invoke(); - assertEquals(id + " Failed test " + data, data.expected, stringCheck); + assertEquals(data.expected, stringCheck, id + " Failed test " + data); } } diff --git a/src/test/java/org/apache/commons/lang3/CharSetTest.java b/src/test/java/org/apache/commons/lang3/CharSetTest.java index 7c8dff427..7401458da 100644 --- a/src/test/java/org/apache/commons/lang3/CharSetTest.java +++ b/src/test/java/org/apache/commons/lang3/CharSetTest.java @@ -18,15 +18,15 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; +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.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.lang.reflect.Modifier; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Unit tests {@link org.apache.commons.lang3.CharSet}. diff --git a/src/test/java/org/apache/commons/lang3/CharSetUtilsTest.java b/src/test/java/org/apache/commons/lang3/CharSetUtilsTest.java index 2f1296adb..1c95925c0 100644 --- a/src/test/java/org/apache/commons/lang3/CharSetUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/CharSetUtilsTest.java @@ -16,16 +16,16 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.lang.reflect.Constructor; import java.lang.reflect.Modifier; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Unit tests {@link org.apache.commons.lang3.CharSetUtils}. diff --git a/src/test/java/org/apache/commons/lang3/CharUtilsTest.java b/src/test/java/org/apache/commons/lang3/CharUtilsTest.java index 3b3128beb..1b3716a19 100644 --- a/src/test/java/org/apache/commons/lang3/CharUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/CharUtilsTest.java @@ -16,18 +16,18 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; import java.lang.reflect.Constructor; import java.lang.reflect.Modifier; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Unit tests {@link org.apache.commons.lang3.CharUtils}. diff --git a/src/test/java/org/apache/commons/lang3/ClassPathUtilsTest.java b/src/test/java/org/apache/commons/lang3/ClassPathUtilsTest.java index 4dfd5d0c5..ff67b8d23 100644 --- a/src/test/java/org/apache/commons/lang3/ClassPathUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/ClassPathUtilsTest.java @@ -16,15 +16,16 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.lang.reflect.Constructor; import java.lang.reflect.Modifier; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** */ @@ -40,14 +41,15 @@ public class ClassPathUtilsTest { assertFalse(Modifier.isFinal(ClassPathUtils.class.getModifiers())); } - @Test(expected = NullPointerException.class) - public void testToFullyQualifiedNameNullClassString() throws Exception { - ClassPathUtils.toFullyQualifiedName((Class) null, "Test.properties"); + @Test + public void testToFullyQualifiedNameNullClassString() { + assertThrows(NullPointerException.class, + () -> ClassPathUtils.toFullyQualifiedName((Class) null, "Test.properties")); } - @Test(expected = NullPointerException.class) - public void testToFullyQualifiedNameClassNull() throws Exception { - ClassPathUtils.toFullyQualifiedName(ClassPathUtils.class, null); + @Test + public void testToFullyQualifiedNameClassNull() { + assertThrows(NullPointerException.class, () -> ClassPathUtils.toFullyQualifiedName(ClassPathUtils.class, null)); } @Test @@ -58,14 +60,16 @@ public class ClassPathUtilsTest { assertEquals(expected, actual); } - @Test(expected = NullPointerException.class) - public void testToFullyQualifiedNameNullPackageString() throws Exception { - ClassPathUtils.toFullyQualifiedName((Package) null, "Test.properties"); + @Test + public void testToFullyQualifiedNameNullPackageString() { + assertThrows(NullPointerException.class, + () -> ClassPathUtils.toFullyQualifiedName((Package) null, "Test.properties")); } - @Test(expected = NullPointerException.class) - public void testToFullyQualifiedNamePackageNull() throws Exception { - ClassPathUtils.toFullyQualifiedName(ClassPathUtils.class.getPackage(), null); + @Test + public void testToFullyQualifiedNamePackageNull() { + assertThrows(NullPointerException.class, + () -> ClassPathUtils.toFullyQualifiedName(ClassPathUtils.class.getPackage(), null)); } @Test @@ -76,14 +80,15 @@ public class ClassPathUtilsTest { assertEquals(expected, actual); } - @Test(expected = NullPointerException.class) - public void testToFullyQualifiedPathClassNullString() throws Exception { - ClassPathUtils.toFullyQualifiedPath((Class) null, "Test.properties"); + @Test + public void testToFullyQualifiedPathClassNullString() { + assertThrows(NullPointerException.class, + () -> ClassPathUtils.toFullyQualifiedPath((Class) null, "Test.properties")); } - @Test(expected = NullPointerException.class) - public void testToFullyQualifiedPathClassNull() throws Exception { - ClassPathUtils.toFullyQualifiedPath(ClassPathUtils.class, null); + @Test + public void testToFullyQualifiedPathClassNull() { + assertThrows(NullPointerException.class, () -> ClassPathUtils.toFullyQualifiedPath(ClassPathUtils.class, null)); } @Test @@ -94,14 +99,16 @@ public class ClassPathUtilsTest { assertEquals(expected, actual); } - @Test(expected = NullPointerException.class) - public void testToFullyQualifiedPathPackageNullString() throws Exception { - ClassPathUtils.toFullyQualifiedPath((Package) null, "Test.properties"); + @Test + public void testToFullyQualifiedPathPackageNullString() { + assertThrows(NullPointerException.class, + () -> ClassPathUtils.toFullyQualifiedPath((Package) null, "Test.properties")); } - @Test(expected = NullPointerException.class) - public void testToFullyQualifiedPathPackageNull() throws Exception { - ClassPathUtils.toFullyQualifiedPath(ClassPathUtils.class.getPackage(), null); + @Test + public void testToFullyQualifiedPathPackageNull() { + assertThrows(NullPointerException.class, + () -> ClassPathUtils.toFullyQualifiedPath(ClassPathUtils.class.getPackage(), null)); } @Test diff --git a/src/test/java/org/apache/commons/lang3/ClassUtilsTest.java b/src/test/java/org/apache/commons/lang3/ClassUtilsTest.java index 7d9d6f681..84c113908 100644 --- a/src/test/java/org/apache/commons/lang3/ClassUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/ClassUtilsTest.java @@ -16,15 +16,16 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNotSame; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +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.lang.reflect.Constructor; import java.lang.reflect.Method; @@ -42,7 +43,7 @@ import org.apache.commons.lang3.ClassUtils.Interfaces; import org.apache.commons.lang3.reflect.testbed.GenericConsumer; import org.apache.commons.lang3.reflect.testbed.GenericParent; import org.apache.commons.lang3.reflect.testbed.StringParameterizedChild; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Unit tests {@link org.apache.commons.lang3.ClassUtils}. @@ -175,14 +176,14 @@ public class ClassUtilsTest { assertEquals("java.lang.String", ClassUtils.getAbbreviatedName(String.class, 20)); } - @Test(expected = IllegalArgumentException.class) + @Test public void test_getAbbreviatedName_Class_NegativeLen() { - ClassUtils.getAbbreviatedName(String.class, -10); + assertThrows(IllegalArgumentException.class, () -> ClassUtils.getAbbreviatedName(String.class, -10)); } - @Test(expected = IllegalArgumentException.class) + @Test public void test_getAbbreviatedName_Class_ZeroLen() { - ClassUtils.getAbbreviatedName(String.class, 0); + assertThrows(IllegalArgumentException.class, () -> ClassUtils.getAbbreviatedName(String.class, 0)); } @Test @@ -813,84 +814,84 @@ public class ClassUtilsTest { @Test public void test_isAssignable_DefaultUnboxing_Widening() throws Exception { // test byte conversions - assertFalse("byte -> char", ClassUtils.isAssignable(Byte.class, Character.TYPE)); - assertTrue("byte -> byte", ClassUtils.isAssignable(Byte.class, Byte.TYPE)); - assertTrue("byte -> short", ClassUtils.isAssignable(Byte.class, Short.TYPE)); - assertTrue("byte -> int", ClassUtils.isAssignable(Byte.class, Integer.TYPE)); - assertTrue("byte -> long", ClassUtils.isAssignable(Byte.class, Long.TYPE)); - assertTrue("byte -> float", ClassUtils.isAssignable(Byte.class, Float.TYPE)); - assertTrue("byte -> double", ClassUtils.isAssignable(Byte.class, Double.TYPE)); - assertFalse("byte -> boolean", ClassUtils.isAssignable(Byte.class, Boolean.TYPE)); + assertFalse(ClassUtils.isAssignable(Byte.class, Character.TYPE), "byte -> char"); + assertTrue(ClassUtils.isAssignable(Byte.class, Byte.TYPE), "byte -> byte"); + assertTrue(ClassUtils.isAssignable(Byte.class, Short.TYPE), "byte -> short"); + assertTrue(ClassUtils.isAssignable(Byte.class, Integer.TYPE), "byte -> int"); + assertTrue(ClassUtils.isAssignable(Byte.class, Long.TYPE), "byte -> long"); + assertTrue(ClassUtils.isAssignable(Byte.class, Float.TYPE), "byte -> float"); + assertTrue(ClassUtils.isAssignable(Byte.class, Double.TYPE), "byte -> double"); + assertFalse(ClassUtils.isAssignable(Byte.class, Boolean.TYPE), "byte -> boolean"); // test short conversions - assertFalse("short -> char", ClassUtils.isAssignable(Short.class, Character.TYPE)); - assertFalse("short -> byte", ClassUtils.isAssignable(Short.class, Byte.TYPE)); - assertTrue("short -> short", ClassUtils.isAssignable(Short.class, Short.TYPE)); - assertTrue("short -> int", ClassUtils.isAssignable(Short.class, Integer.TYPE)); - assertTrue("short -> long", ClassUtils.isAssignable(Short.class, Long.TYPE)); - assertTrue("short -> float", ClassUtils.isAssignable(Short.class, Float.TYPE)); - assertTrue("short -> double", ClassUtils.isAssignable(Short.class, Double.TYPE)); - assertFalse("short -> boolean", ClassUtils.isAssignable(Short.class, Boolean.TYPE)); + assertFalse(ClassUtils.isAssignable(Short.class, Character.TYPE), "short -> char"); + assertFalse(ClassUtils.isAssignable(Short.class, Byte.TYPE), "short -> byte"); + assertTrue(ClassUtils.isAssignable(Short.class, Short.TYPE), "short -> short"); + assertTrue(ClassUtils.isAssignable(Short.class, Integer.TYPE), "short -> int"); + assertTrue(ClassUtils.isAssignable(Short.class, Long.TYPE), "short -> long"); + assertTrue(ClassUtils.isAssignable(Short.class, Float.TYPE), "short -> float"); + assertTrue(ClassUtils.isAssignable(Short.class, Double.TYPE), "short -> double"); + assertFalse(ClassUtils.isAssignable(Short.class, Boolean.TYPE), "short -> boolean"); // test char conversions - assertTrue("char -> char", ClassUtils.isAssignable(Character.class, Character.TYPE)); - assertFalse("char -> byte", ClassUtils.isAssignable(Character.class, Byte.TYPE)); - assertFalse("char -> short", ClassUtils.isAssignable(Character.class, Short.TYPE)); - assertTrue("char -> int", ClassUtils.isAssignable(Character.class, Integer.TYPE)); - assertTrue("char -> long", ClassUtils.isAssignable(Character.class, Long.TYPE)); - assertTrue("char -> float", ClassUtils.isAssignable(Character.class, Float.TYPE)); - assertTrue("char -> double", ClassUtils.isAssignable(Character.class, Double.TYPE)); - assertFalse("char -> boolean", ClassUtils.isAssignable(Character.class, Boolean.TYPE)); + assertTrue(ClassUtils.isAssignable(Character.class, Character.TYPE), "char -> char"); + assertFalse(ClassUtils.isAssignable(Character.class, Byte.TYPE), "char -> byte"); + assertFalse(ClassUtils.isAssignable(Character.class, Short.TYPE), "char -> short"); + assertTrue(ClassUtils.isAssignable(Character.class, Integer.TYPE), "char -> int"); + assertTrue(ClassUtils.isAssignable(Character.class, Long.TYPE), "char -> long"); + assertTrue(ClassUtils.isAssignable(Character.class, Float.TYPE), "char -> float"); + assertTrue(ClassUtils.isAssignable(Character.class, Double.TYPE), "char -> double"); + assertFalse(ClassUtils.isAssignable(Character.class, Boolean.TYPE), "char -> boolean"); // test int conversions - assertFalse("int -> char", ClassUtils.isAssignable(Integer.class, Character.TYPE)); - assertFalse("int -> byte", ClassUtils.isAssignable(Integer.class, Byte.TYPE)); - assertFalse("int -> short", ClassUtils.isAssignable(Integer.class, Short.TYPE)); - assertTrue("int -> int", ClassUtils.isAssignable(Integer.class, Integer.TYPE)); - assertTrue("int -> long", ClassUtils.isAssignable(Integer.class, Long.TYPE)); - assertTrue("int -> float", ClassUtils.isAssignable(Integer.class, Float.TYPE)); - assertTrue("int -> double", ClassUtils.isAssignable(Integer.class, Double.TYPE)); - assertFalse("int -> boolean", ClassUtils.isAssignable(Integer.class, Boolean.TYPE)); + assertFalse(ClassUtils.isAssignable(Integer.class, Character.TYPE), "int -> char"); + assertFalse(ClassUtils.isAssignable(Integer.class, Byte.TYPE), "int -> byte"); + assertFalse(ClassUtils.isAssignable(Integer.class, Short.TYPE), "int -> short"); + assertTrue(ClassUtils.isAssignable(Integer.class, Integer.TYPE), "int -> int"); + assertTrue(ClassUtils.isAssignable(Integer.class, Long.TYPE), "int -> long"); + assertTrue(ClassUtils.isAssignable(Integer.class, Float.TYPE), "int -> float"); + assertTrue(ClassUtils.isAssignable(Integer.class, Double.TYPE), "int -> double"); + assertFalse(ClassUtils.isAssignable(Integer.class, Boolean.TYPE), "int -> boolean"); // test long conversions - assertFalse("long -> char", ClassUtils.isAssignable(Long.class, Character.TYPE)); - assertFalse("long -> byte", ClassUtils.isAssignable(Long.class, Byte.TYPE)); - assertFalse("long -> short", ClassUtils.isAssignable(Long.class, Short.TYPE)); - assertFalse("long -> int", ClassUtils.isAssignable(Long.class, Integer.TYPE)); - assertTrue("long -> long", ClassUtils.isAssignable(Long.class, Long.TYPE)); - assertTrue("long -> float", ClassUtils.isAssignable(Long.class, Float.TYPE)); - assertTrue("long -> double", ClassUtils.isAssignable(Long.class, Double.TYPE)); - assertFalse("long -> boolean", ClassUtils.isAssignable(Long.class, Boolean.TYPE)); + assertFalse(ClassUtils.isAssignable(Long.class, Character.TYPE), "long -> char"); + assertFalse(ClassUtils.isAssignable(Long.class, Byte.TYPE), "long -> byte"); + assertFalse(ClassUtils.isAssignable(Long.class, Short.TYPE), "long -> short"); + assertFalse(ClassUtils.isAssignable(Long.class, Integer.TYPE), "long -> int"); + assertTrue(ClassUtils.isAssignable(Long.class, Long.TYPE), "long -> long"); + assertTrue(ClassUtils.isAssignable(Long.class, Float.TYPE), "long -> float"); + assertTrue(ClassUtils.isAssignable(Long.class, Double.TYPE), "long -> double"); + assertFalse(ClassUtils.isAssignable(Long.class, Boolean.TYPE), "long -> boolean"); // test float conversions - assertFalse("float -> char", ClassUtils.isAssignable(Float.class, Character.TYPE)); - assertFalse("float -> byte", ClassUtils.isAssignable(Float.class, Byte.TYPE)); - assertFalse("float -> short", ClassUtils.isAssignable(Float.class, Short.TYPE)); - assertFalse("float -> int", ClassUtils.isAssignable(Float.class, Integer.TYPE)); - assertFalse("float -> long", ClassUtils.isAssignable(Float.class, Long.TYPE)); - assertTrue("float -> float", ClassUtils.isAssignable(Float.class, Float.TYPE)); - assertTrue("float -> double", ClassUtils.isAssignable(Float.class, Double.TYPE)); - assertFalse("float -> boolean", ClassUtils.isAssignable(Float.class, Boolean.TYPE)); + assertFalse(ClassUtils.isAssignable(Float.class, Character.TYPE), "float -> char"); + assertFalse(ClassUtils.isAssignable(Float.class, Byte.TYPE), "float -> byte"); + assertFalse(ClassUtils.isAssignable(Float.class, Short.TYPE), "float -> short"); + assertFalse(ClassUtils.isAssignable(Float.class, Integer.TYPE), "float -> int"); + assertFalse(ClassUtils.isAssignable(Float.class, Long.TYPE), "float -> long"); + assertTrue(ClassUtils.isAssignable(Float.class, Float.TYPE), "float -> float"); + assertTrue(ClassUtils.isAssignable(Float.class, Double.TYPE), "float -> double"); + assertFalse(ClassUtils.isAssignable(Float.class, Boolean.TYPE), "float -> boolean"); // test double conversions - assertFalse("double -> char", ClassUtils.isAssignable(Double.class, Character.TYPE)); - assertFalse("double -> byte", ClassUtils.isAssignable(Double.class, Byte.TYPE)); - assertFalse("double -> short", ClassUtils.isAssignable(Double.class, Short.TYPE)); - assertFalse("double -> int", ClassUtils.isAssignable(Double.class, Integer.TYPE)); - assertFalse("double -> long", ClassUtils.isAssignable(Double.class, Long.TYPE)); - assertFalse("double -> float", ClassUtils.isAssignable(Double.class, Float.TYPE)); - assertTrue("double -> double", ClassUtils.isAssignable(Double.class, Double.TYPE)); - assertFalse("double -> boolean", ClassUtils.isAssignable(Double.class, Boolean.TYPE)); + assertFalse(ClassUtils.isAssignable(Double.class, Character.TYPE), "double -> char"); + assertFalse(ClassUtils.isAssignable(Double.class, Byte.TYPE), "double -> byte"); + assertFalse(ClassUtils.isAssignable(Double.class, Short.TYPE), "double -> short"); + assertFalse(ClassUtils.isAssignable(Double.class, Integer.TYPE), "double -> int"); + assertFalse(ClassUtils.isAssignable(Double.class, Long.TYPE), "double -> long"); + assertFalse(ClassUtils.isAssignable(Double.class, Float.TYPE), "double -> float"); + assertTrue(ClassUtils.isAssignable(Double.class, Double.TYPE), "double -> double"); + assertFalse(ClassUtils.isAssignable(Double.class, Boolean.TYPE), "double -> boolean"); // test boolean conversions - assertFalse("boolean -> char", ClassUtils.isAssignable(Boolean.class, Character.TYPE)); - assertFalse("boolean -> byte", ClassUtils.isAssignable(Boolean.class, Byte.TYPE)); - assertFalse("boolean -> short", ClassUtils.isAssignable(Boolean.class, Short.TYPE)); - assertFalse("boolean -> int", ClassUtils.isAssignable(Boolean.class, Integer.TYPE)); - assertFalse("boolean -> long", ClassUtils.isAssignable(Boolean.class, Long.TYPE)); - assertFalse("boolean -> float", ClassUtils.isAssignable(Boolean.class, Float.TYPE)); - assertFalse("boolean -> double", ClassUtils.isAssignable(Boolean.class, Double.TYPE)); - assertTrue("boolean -> boolean", ClassUtils.isAssignable(Boolean.class, Boolean.TYPE)); + assertFalse(ClassUtils.isAssignable(Boolean.class, Character.TYPE), "boolean -> char"); + assertFalse(ClassUtils.isAssignable(Boolean.class, Byte.TYPE), "boolean -> byte"); + assertFalse(ClassUtils.isAssignable(Boolean.class, Short.TYPE), "boolean -> short"); + assertFalse(ClassUtils.isAssignable(Boolean.class, Integer.TYPE), "boolean -> int"); + assertFalse(ClassUtils.isAssignable(Boolean.class, Long.TYPE), "boolean -> long"); + assertFalse(ClassUtils.isAssignable(Boolean.class, Float.TYPE), "boolean -> float"); + assertFalse(ClassUtils.isAssignable(Boolean.class, Double.TYPE), "boolean -> double"); + assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.TYPE), "boolean -> boolean"); } @Test @@ -920,167 +921,167 @@ public class ClassUtilsTest { @Test public void test_isAssignable_Unboxing_Widening() throws Exception { // test byte conversions - assertFalse("byte -> char", ClassUtils.isAssignable(Byte.class, Character.TYPE, true)); - assertTrue("byte -> byte", ClassUtils.isAssignable(Byte.class, Byte.TYPE, true)); - assertTrue("byte -> short", ClassUtils.isAssignable(Byte.class, Short.TYPE, true)); - assertTrue("byte -> int", ClassUtils.isAssignable(Byte.class, Integer.TYPE, true)); - assertTrue("byte -> long", ClassUtils.isAssignable(Byte.class, Long.TYPE, true)); - assertTrue("byte -> float", ClassUtils.isAssignable(Byte.class, Float.TYPE, true)); - assertTrue("byte -> double", ClassUtils.isAssignable(Byte.class, Double.TYPE, true)); - assertFalse("byte -> boolean", ClassUtils.isAssignable(Byte.class, Boolean.TYPE, true)); + assertFalse(ClassUtils.isAssignable(Byte.class, Character.TYPE, true), "byte -> char"); + assertTrue(ClassUtils.isAssignable(Byte.class, Byte.TYPE, true), "byte -> byte"); + assertTrue(ClassUtils.isAssignable(Byte.class, Short.TYPE, true), "byte -> short"); + assertTrue(ClassUtils.isAssignable(Byte.class, Integer.TYPE, true), "byte -> int"); + assertTrue(ClassUtils.isAssignable(Byte.class, Long.TYPE, true), "byte -> long"); + assertTrue(ClassUtils.isAssignable(Byte.class, Float.TYPE, true), "byte -> float"); + assertTrue(ClassUtils.isAssignable(Byte.class, Double.TYPE, true), "byte -> double"); + assertFalse(ClassUtils.isAssignable(Byte.class, Boolean.TYPE, true), "byte -> boolean"); // test short conversions - assertFalse("short -> char", ClassUtils.isAssignable(Short.class, Character.TYPE, true)); - assertFalse("short -> byte", ClassUtils.isAssignable(Short.class, Byte.TYPE, true)); - assertTrue("short -> short", ClassUtils.isAssignable(Short.class, Short.TYPE, true)); - assertTrue("short -> int", ClassUtils.isAssignable(Short.class, Integer.TYPE, true)); - assertTrue("short -> long", ClassUtils.isAssignable(Short.class, Long.TYPE, true)); - assertTrue("short -> float", ClassUtils.isAssignable(Short.class, Float.TYPE, true)); - assertTrue("short -> double", ClassUtils.isAssignable(Short.class, Double.TYPE, true)); - assertFalse("short -> boolean", ClassUtils.isAssignable(Short.class, Boolean.TYPE, true)); + assertFalse(ClassUtils.isAssignable(Short.class, Character.TYPE, true), "short -> char"); + assertFalse(ClassUtils.isAssignable(Short.class, Byte.TYPE, true), "short -> byte"); + assertTrue(ClassUtils.isAssignable(Short.class, Short.TYPE, true), "short -> short"); + assertTrue(ClassUtils.isAssignable(Short.class, Integer.TYPE, true), "short -> int"); + assertTrue(ClassUtils.isAssignable(Short.class, Long.TYPE, true), "short -> long"); + assertTrue(ClassUtils.isAssignable(Short.class, Float.TYPE, true), "short -> float"); + assertTrue(ClassUtils.isAssignable(Short.class, Double.TYPE, true), "short -> double"); + assertFalse(ClassUtils.isAssignable(Short.class, Boolean.TYPE, true), "short -> boolean"); // test char conversions - assertTrue("char -> char", ClassUtils.isAssignable(Character.class, Character.TYPE, true)); - assertFalse("char -> byte", ClassUtils.isAssignable(Character.class, Byte.TYPE, true)); - assertFalse("char -> short", ClassUtils.isAssignable(Character.class, Short.TYPE, true)); - assertTrue("char -> int", ClassUtils.isAssignable(Character.class, Integer.TYPE, true)); - assertTrue("char -> long", ClassUtils.isAssignable(Character.class, Long.TYPE, true)); - assertTrue("char -> float", ClassUtils.isAssignable(Character.class, Float.TYPE, true)); - assertTrue("char -> double", ClassUtils.isAssignable(Character.class, Double.TYPE, true)); - assertFalse("char -> boolean", ClassUtils.isAssignable(Character.class, Boolean.TYPE, true)); + assertTrue(ClassUtils.isAssignable(Character.class, Character.TYPE, true), "char -> char"); + assertFalse(ClassUtils.isAssignable(Character.class, Byte.TYPE, true), "char -> byte"); + assertFalse(ClassUtils.isAssignable(Character.class, Short.TYPE, true), "char -> short"); + assertTrue(ClassUtils.isAssignable(Character.class, Integer.TYPE, true), "char -> int"); + assertTrue(ClassUtils.isAssignable(Character.class, Long.TYPE, true), "char -> long"); + assertTrue(ClassUtils.isAssignable(Character.class, Float.TYPE, true), "char -> float"); + assertTrue(ClassUtils.isAssignable(Character.class, Double.TYPE, true), "char -> double"); + assertFalse(ClassUtils.isAssignable(Character.class, Boolean.TYPE, true), "char -> boolean"); // test int conversions - assertFalse("int -> char", ClassUtils.isAssignable(Integer.class, Character.TYPE, true)); - assertFalse("int -> byte", ClassUtils.isAssignable(Integer.class, Byte.TYPE, true)); - assertFalse("int -> short", ClassUtils.isAssignable(Integer.class, Short.TYPE, true)); - assertTrue("int -> int", ClassUtils.isAssignable(Integer.class, Integer.TYPE, true)); - assertTrue("int -> long", ClassUtils.isAssignable(Integer.class, Long.TYPE, true)); - assertTrue("int -> float", ClassUtils.isAssignable(Integer.class, Float.TYPE, true)); - assertTrue("int -> double", ClassUtils.isAssignable(Integer.class, Double.TYPE, true)); - assertFalse("int -> boolean", ClassUtils.isAssignable(Integer.class, Boolean.TYPE, true)); + assertFalse(ClassUtils.isAssignable(Integer.class, Character.TYPE, true), "int -> char"); + assertFalse(ClassUtils.isAssignable(Integer.class, Byte.TYPE, true), "int -> byte"); + assertFalse(ClassUtils.isAssignable(Integer.class, Short.TYPE, true), "int -> short"); + assertTrue(ClassUtils.isAssignable(Integer.class, Integer.TYPE, true), "int -> int"); + assertTrue(ClassUtils.isAssignable(Integer.class, Long.TYPE, true), "int -> long"); + assertTrue(ClassUtils.isAssignable(Integer.class, Float.TYPE, true), "int -> float"); + assertTrue(ClassUtils.isAssignable(Integer.class, Double.TYPE, true), "int -> double"); + assertFalse(ClassUtils.isAssignable(Integer.class, Boolean.TYPE, true), "int -> boolean"); // test long conversions - assertFalse("long -> char", ClassUtils.isAssignable(Long.class, Character.TYPE, true)); - assertFalse("long -> byte", ClassUtils.isAssignable(Long.class, Byte.TYPE, true)); - assertFalse("long -> short", ClassUtils.isAssignable(Long.class, Short.TYPE, true)); - assertFalse("long -> int", ClassUtils.isAssignable(Long.class, Integer.TYPE, true)); - assertTrue("long -> long", ClassUtils.isAssignable(Long.class, Long.TYPE, true)); - assertTrue("long -> float", ClassUtils.isAssignable(Long.class, Float.TYPE, true)); - assertTrue("long -> double", ClassUtils.isAssignable(Long.class, Double.TYPE, true)); - assertFalse("long -> boolean", ClassUtils.isAssignable(Long.class, Boolean.TYPE, true)); + assertFalse(ClassUtils.isAssignable(Long.class, Character.TYPE, true), "long -> char"); + assertFalse(ClassUtils.isAssignable(Long.class, Byte.TYPE, true), "long -> byte"); + assertFalse(ClassUtils.isAssignable(Long.class, Short.TYPE, true), "long -> short"); + assertFalse(ClassUtils.isAssignable(Long.class, Integer.TYPE, true), "long -> int"); + assertTrue(ClassUtils.isAssignable(Long.class, Long.TYPE, true), "long -> long"); + assertTrue(ClassUtils.isAssignable(Long.class, Float.TYPE, true), "long -> float"); + assertTrue(ClassUtils.isAssignable(Long.class, Double.TYPE, true), "long -> double"); + assertFalse(ClassUtils.isAssignable(Long.class, Boolean.TYPE, true), "long -> boolean"); // test float conversions - assertFalse("float -> char", ClassUtils.isAssignable(Float.class, Character.TYPE, true)); - assertFalse("float -> byte", ClassUtils.isAssignable(Float.class, Byte.TYPE, true)); - assertFalse("float -> short", ClassUtils.isAssignable(Float.class, Short.TYPE, true)); - assertFalse("float -> int", ClassUtils.isAssignable(Float.class, Integer.TYPE, true)); - assertFalse("float -> long", ClassUtils.isAssignable(Float.class, Long.TYPE, true)); - assertTrue("float -> float", ClassUtils.isAssignable(Float.class, Float.TYPE, true)); - assertTrue("float -> double", ClassUtils.isAssignable(Float.class, Double.TYPE, true)); - assertFalse("float -> boolean", ClassUtils.isAssignable(Float.class, Boolean.TYPE, true)); + assertFalse(ClassUtils.isAssignable(Float.class, Character.TYPE, true), "float -> char"); + assertFalse(ClassUtils.isAssignable(Float.class, Byte.TYPE, true), "float -> byte"); + assertFalse(ClassUtils.isAssignable(Float.class, Short.TYPE, true), "float -> short"); + assertFalse(ClassUtils.isAssignable(Float.class, Integer.TYPE, true), "float -> int"); + assertFalse(ClassUtils.isAssignable(Float.class, Long.TYPE, true), "float -> long"); + assertTrue(ClassUtils.isAssignable(Float.class, Float.TYPE, true), "float -> float"); + assertTrue(ClassUtils.isAssignable(Float.class, Double.TYPE, true), "float -> double"); + assertFalse(ClassUtils.isAssignable(Float.class, Boolean.TYPE, true), "float -> boolean"); // test double conversions - assertFalse("double -> char", ClassUtils.isAssignable(Double.class, Character.TYPE, true)); - assertFalse("double -> byte", ClassUtils.isAssignable(Double.class, Byte.TYPE, true)); - assertFalse("double -> short", ClassUtils.isAssignable(Double.class, Short.TYPE, true)); - assertFalse("double -> int", ClassUtils.isAssignable(Double.class, Integer.TYPE, true)); - assertFalse("double -> long", ClassUtils.isAssignable(Double.class, Long.TYPE, true)); - assertFalse("double -> float", ClassUtils.isAssignable(Double.class, Float.TYPE, true)); - assertTrue("double -> double", ClassUtils.isAssignable(Double.class, Double.TYPE, true)); - assertFalse("double -> boolean", ClassUtils.isAssignable(Double.class, Boolean.TYPE, true)); + assertFalse(ClassUtils.isAssignable(Double.class, Character.TYPE, true), "double -> char"); + assertFalse(ClassUtils.isAssignable(Double.class, Byte.TYPE, true), "double -> byte"); + assertFalse(ClassUtils.isAssignable(Double.class, Short.TYPE, true), "double -> short"); + assertFalse(ClassUtils.isAssignable(Double.class, Integer.TYPE, true), "double -> int"); + assertFalse(ClassUtils.isAssignable(Double.class, Long.TYPE, true), "double -> long"); + assertFalse(ClassUtils.isAssignable(Double.class, Float.TYPE, true), "double -> float"); + assertTrue(ClassUtils.isAssignable(Double.class, Double.TYPE, true), "double -> double"); + assertFalse(ClassUtils.isAssignable(Double.class, Boolean.TYPE, true), "double -> boolean"); // test boolean conversions - assertFalse("boolean -> char", ClassUtils.isAssignable(Boolean.class, Character.TYPE, true)); - assertFalse("boolean -> byte", ClassUtils.isAssignable(Boolean.class, Byte.TYPE, true)); - assertFalse("boolean -> short", ClassUtils.isAssignable(Boolean.class, Short.TYPE, true)); - assertFalse("boolean -> int", ClassUtils.isAssignable(Boolean.class, Integer.TYPE, true)); - assertFalse("boolean -> long", ClassUtils.isAssignable(Boolean.class, Long.TYPE, true)); - assertFalse("boolean -> float", ClassUtils.isAssignable(Boolean.class, Float.TYPE, true)); - assertFalse("boolean -> double", ClassUtils.isAssignable(Boolean.class, Double.TYPE, true)); - assertTrue("boolean -> boolean", ClassUtils.isAssignable(Boolean.class, Boolean.TYPE, true)); + assertFalse(ClassUtils.isAssignable(Boolean.class, Character.TYPE, true), "boolean -> char"); + assertFalse(ClassUtils.isAssignable(Boolean.class, Byte.TYPE, true), "boolean -> byte"); + assertFalse(ClassUtils.isAssignable(Boolean.class, Short.TYPE, true), "boolean -> short"); + assertFalse(ClassUtils.isAssignable(Boolean.class, Integer.TYPE, true), "boolean -> int"); + assertFalse(ClassUtils.isAssignable(Boolean.class, Long.TYPE, true), "boolean -> long"); + assertFalse(ClassUtils.isAssignable(Boolean.class, Float.TYPE, true), "boolean -> float"); + assertFalse(ClassUtils.isAssignable(Boolean.class, Double.TYPE, true), "boolean -> double"); + assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.TYPE, true), "boolean -> boolean"); } @Test public void test_isAssignable_Widening() throws Exception { // test byte conversions - assertFalse("byte -> char", ClassUtils.isAssignable(Byte.TYPE, Character.TYPE)); - assertTrue("byte -> byte", ClassUtils.isAssignable(Byte.TYPE, Byte.TYPE)); - assertTrue("byte -> short", ClassUtils.isAssignable(Byte.TYPE, Short.TYPE)); - assertTrue("byte -> int", ClassUtils.isAssignable(Byte.TYPE, Integer.TYPE)); - assertTrue("byte -> long", ClassUtils.isAssignable(Byte.TYPE, Long.TYPE)); - assertTrue("byte -> float", ClassUtils.isAssignable(Byte.TYPE, Float.TYPE)); - assertTrue("byte -> double", ClassUtils.isAssignable(Byte.TYPE, Double.TYPE)); - assertFalse("byte -> boolean", ClassUtils.isAssignable(Byte.TYPE, Boolean.TYPE)); + assertFalse(ClassUtils.isAssignable(Byte.TYPE, Character.TYPE), "byte -> char"); + assertTrue(ClassUtils.isAssignable(Byte.TYPE, Byte.TYPE), "byte -> byte"); + assertTrue(ClassUtils.isAssignable(Byte.TYPE, Short.TYPE), "byte -> short"); + assertTrue(ClassUtils.isAssignable(Byte.TYPE, Integer.TYPE), "byte -> int"); + assertTrue(ClassUtils.isAssignable(Byte.TYPE, Long.TYPE), "byte -> long"); + assertTrue(ClassUtils.isAssignable(Byte.TYPE, Float.TYPE), "byte -> float"); + assertTrue(ClassUtils.isAssignable(Byte.TYPE, Double.TYPE), "byte -> double"); + assertFalse(ClassUtils.isAssignable(Byte.TYPE, Boolean.TYPE), "byte -> boolean"); // test short conversions - assertFalse("short -> char", ClassUtils.isAssignable(Short.TYPE, Character.TYPE)); - assertFalse("short -> byte", ClassUtils.isAssignable(Short.TYPE, Byte.TYPE)); - assertTrue("short -> short", ClassUtils.isAssignable(Short.TYPE, Short.TYPE)); - assertTrue("short -> int", ClassUtils.isAssignable(Short.TYPE, Integer.TYPE)); - assertTrue("short -> long", ClassUtils.isAssignable(Short.TYPE, Long.TYPE)); - assertTrue("short -> float", ClassUtils.isAssignable(Short.TYPE, Float.TYPE)); - assertTrue("short -> double", ClassUtils.isAssignable(Short.TYPE, Double.TYPE)); - assertFalse("short -> boolean", ClassUtils.isAssignable(Short.TYPE, Boolean.TYPE)); + assertFalse(ClassUtils.isAssignable(Short.TYPE, Character.TYPE), "short -> char"); + assertFalse(ClassUtils.isAssignable(Short.TYPE, Byte.TYPE), "short -> byte"); + assertTrue(ClassUtils.isAssignable(Short.TYPE, Short.TYPE), "short -> short"); + assertTrue(ClassUtils.isAssignable(Short.TYPE, Integer.TYPE), "short -> int"); + assertTrue(ClassUtils.isAssignable(Short.TYPE, Long.TYPE), "short -> long"); + assertTrue(ClassUtils.isAssignable(Short.TYPE, Float.TYPE), "short -> float"); + assertTrue(ClassUtils.isAssignable(Short.TYPE, Double.TYPE), "short -> double"); + assertFalse(ClassUtils.isAssignable(Short.TYPE, Boolean.TYPE), "short -> boolean"); // test char conversions - assertTrue("char -> char", ClassUtils.isAssignable(Character.TYPE, Character.TYPE)); - assertFalse("char -> byte", ClassUtils.isAssignable(Character.TYPE, Byte.TYPE)); - assertFalse("char -> short", ClassUtils.isAssignable(Character.TYPE, Short.TYPE)); - assertTrue("char -> int", ClassUtils.isAssignable(Character.TYPE, Integer.TYPE)); - assertTrue("char -> long", ClassUtils.isAssignable(Character.TYPE, Long.TYPE)); - assertTrue("char -> float", ClassUtils.isAssignable(Character.TYPE, Float.TYPE)); - assertTrue("char -> double", ClassUtils.isAssignable(Character.TYPE, Double.TYPE)); - assertFalse("char -> boolean", ClassUtils.isAssignable(Character.TYPE, Boolean.TYPE)); + assertTrue(ClassUtils.isAssignable(Character.TYPE, Character.TYPE), "char -> char"); + assertFalse(ClassUtils.isAssignable(Character.TYPE, Byte.TYPE), "char -> byte"); + assertFalse(ClassUtils.isAssignable(Character.TYPE, Short.TYPE), "char -> short"); + assertTrue(ClassUtils.isAssignable(Character.TYPE, Integer.TYPE), "char -> int"); + assertTrue(ClassUtils.isAssignable(Character.TYPE, Long.TYPE), "char -> long"); + assertTrue(ClassUtils.isAssignable(Character.TYPE, Float.TYPE), "char -> float"); + assertTrue(ClassUtils.isAssignable(Character.TYPE, Double.TYPE), "char -> double"); + assertFalse(ClassUtils.isAssignable(Character.TYPE, Boolean.TYPE), "char -> boolean"); // test int conversions - assertFalse("int -> char", ClassUtils.isAssignable(Integer.TYPE, Character.TYPE)); - assertFalse("int -> byte", ClassUtils.isAssignable(Integer.TYPE, Byte.TYPE)); - assertFalse("int -> short", ClassUtils.isAssignable(Integer.TYPE, Short.TYPE)); - assertTrue("int -> int", ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE)); - assertTrue("int -> long", ClassUtils.isAssignable(Integer.TYPE, Long.TYPE)); - assertTrue("int -> float", ClassUtils.isAssignable(Integer.TYPE, Float.TYPE)); - assertTrue("int -> double", ClassUtils.isAssignable(Integer.TYPE, Double.TYPE)); - assertFalse("int -> boolean", ClassUtils.isAssignable(Integer.TYPE, Boolean.TYPE)); + assertFalse(ClassUtils.isAssignable(Integer.TYPE, Character.TYPE), "int -> char"); + assertFalse(ClassUtils.isAssignable(Integer.TYPE, Byte.TYPE), "int -> byte"); + assertFalse(ClassUtils.isAssignable(Integer.TYPE, Short.TYPE), "int -> short"); + assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE), "int -> int"); + assertTrue(ClassUtils.isAssignable(Integer.TYPE, Long.TYPE), "int -> long"); + assertTrue(ClassUtils.isAssignable(Integer.TYPE, Float.TYPE), "int -> float"); + assertTrue(ClassUtils.isAssignable(Integer.TYPE, Double.TYPE), "int -> double"); + assertFalse(ClassUtils.isAssignable(Integer.TYPE, Boolean.TYPE), "int -> boolean"); // test long conversions - assertFalse("long -> char", ClassUtils.isAssignable(Long.TYPE, Character.TYPE)); - assertFalse("long -> byte", ClassUtils.isAssignable(Long.TYPE, Byte.TYPE)); - assertFalse("long -> short", ClassUtils.isAssignable(Long.TYPE, Short.TYPE)); - assertFalse("long -> int", ClassUtils.isAssignable(Long.TYPE, Integer.TYPE)); - assertTrue("long -> long", ClassUtils.isAssignable(Long.TYPE, Long.TYPE)); - assertTrue("long -> float", ClassUtils.isAssignable(Long.TYPE, Float.TYPE)); - assertTrue("long -> double", ClassUtils.isAssignable(Long.TYPE, Double.TYPE)); - assertFalse("long -> boolean", ClassUtils.isAssignable(Long.TYPE, Boolean.TYPE)); + assertFalse(ClassUtils.isAssignable(Long.TYPE, Character.TYPE), "long -> char"); + assertFalse(ClassUtils.isAssignable(Long.TYPE, Byte.TYPE), "long -> byte"); + assertFalse(ClassUtils.isAssignable(Long.TYPE, Short.TYPE), "long -> short"); + assertFalse(ClassUtils.isAssignable(Long.TYPE, Integer.TYPE), "long -> int"); + assertTrue(ClassUtils.isAssignable(Long.TYPE, Long.TYPE), "long -> long"); + assertTrue(ClassUtils.isAssignable(Long.TYPE, Float.TYPE), "long -> float"); + assertTrue(ClassUtils.isAssignable(Long.TYPE, Double.TYPE), "long -> double"); + assertFalse(ClassUtils.isAssignable(Long.TYPE, Boolean.TYPE), "long -> boolean"); // test float conversions - assertFalse("float -> char", ClassUtils.isAssignable(Float.TYPE, Character.TYPE)); - assertFalse("float -> byte", ClassUtils.isAssignable(Float.TYPE, Byte.TYPE)); - assertFalse("float -> short", ClassUtils.isAssignable(Float.TYPE, Short.TYPE)); - assertFalse("float -> int", ClassUtils.isAssignable(Float.TYPE, Integer.TYPE)); - assertFalse("float -> long", ClassUtils.isAssignable(Float.TYPE, Long.TYPE)); - assertTrue("float -> float", ClassUtils.isAssignable(Float.TYPE, Float.TYPE)); - assertTrue("float -> double", ClassUtils.isAssignable(Float.TYPE, Double.TYPE)); - assertFalse("float -> boolean", ClassUtils.isAssignable(Float.TYPE, Boolean.TYPE)); + assertFalse(ClassUtils.isAssignable(Float.TYPE, Character.TYPE), "float -> char"); + assertFalse(ClassUtils.isAssignable(Float.TYPE, Byte.TYPE), "float -> byte"); + assertFalse(ClassUtils.isAssignable(Float.TYPE, Short.TYPE), "float -> short"); + assertFalse(ClassUtils.isAssignable(Float.TYPE, Integer.TYPE), "float -> int"); + assertFalse(ClassUtils.isAssignable(Float.TYPE, Long.TYPE), "float -> long"); + assertTrue(ClassUtils.isAssignable(Float.TYPE, Float.TYPE), "float -> float"); + assertTrue(ClassUtils.isAssignable(Float.TYPE, Double.TYPE), "float -> double"); + assertFalse(ClassUtils.isAssignable(Float.TYPE, Boolean.TYPE), "float -> boolean"); // test double conversions - assertFalse("double -> char", ClassUtils.isAssignable(Double.TYPE, Character.TYPE)); - assertFalse("double -> byte", ClassUtils.isAssignable(Double.TYPE, Byte.TYPE)); - assertFalse("double -> short", ClassUtils.isAssignable(Double.TYPE, Short.TYPE)); - assertFalse("double -> int", ClassUtils.isAssignable(Double.TYPE, Integer.TYPE)); - assertFalse("double -> long", ClassUtils.isAssignable(Double.TYPE, Long.TYPE)); - assertFalse("double -> float", ClassUtils.isAssignable(Double.TYPE, Float.TYPE)); - assertTrue("double -> double", ClassUtils.isAssignable(Double.TYPE, Double.TYPE)); - assertFalse("double -> boolean", ClassUtils.isAssignable(Double.TYPE, Boolean.TYPE)); + assertFalse(ClassUtils.isAssignable(Double.TYPE, Character.TYPE), "double -> char"); + assertFalse(ClassUtils.isAssignable(Double.TYPE, Byte.TYPE), "double -> byte"); + assertFalse(ClassUtils.isAssignable(Double.TYPE, Short.TYPE), "double -> short"); + assertFalse(ClassUtils.isAssignable(Double.TYPE, Integer.TYPE), "double -> int"); + assertFalse(ClassUtils.isAssignable(Double.TYPE, Long.TYPE), "double -> long"); + assertFalse(ClassUtils.isAssignable(Double.TYPE, Float.TYPE), "double -> float"); + assertTrue(ClassUtils.isAssignable(Double.TYPE, Double.TYPE), "double -> double"); + assertFalse(ClassUtils.isAssignable(Double.TYPE, Boolean.TYPE), "double -> boolean"); // test boolean conversions - assertFalse("boolean -> char", ClassUtils.isAssignable(Boolean.TYPE, Character.TYPE)); - assertFalse("boolean -> byte", ClassUtils.isAssignable(Boolean.TYPE, Byte.TYPE)); - assertFalse("boolean -> short", ClassUtils.isAssignable(Boolean.TYPE, Short.TYPE)); - assertFalse("boolean -> int", ClassUtils.isAssignable(Boolean.TYPE, Integer.TYPE)); - assertFalse("boolean -> long", ClassUtils.isAssignable(Boolean.TYPE, Long.TYPE)); - assertFalse("boolean -> float", ClassUtils.isAssignable(Boolean.TYPE, Float.TYPE)); - assertFalse("boolean -> double", ClassUtils.isAssignable(Boolean.TYPE, Double.TYPE)); - assertTrue("boolean -> boolean", ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE)); + assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Character.TYPE), "boolean -> char"); + assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Byte.TYPE), "boolean -> byte"); + assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Short.TYPE), "boolean -> short"); + assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Integer.TYPE), "boolean -> int"); + assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Long.TYPE), "boolean -> long"); + assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Float.TYPE), "boolean -> float"); + assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Double.TYPE), "boolean -> double"); + assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE), "boolean -> boolean"); } // ------------------------------------------------------------------------- @@ -1244,76 +1245,76 @@ public class ClassUtilsTest { public void testIsPrimitiveOrWrapper() { // test primitive wrapper classes - assertTrue("Boolean.class", ClassUtils.isPrimitiveOrWrapper(Boolean.class)); - assertTrue("Byte.class", ClassUtils.isPrimitiveOrWrapper(Byte.class)); - assertTrue("Character.class", ClassUtils.isPrimitiveOrWrapper(Character.class)); - assertTrue("Short.class", ClassUtils.isPrimitiveOrWrapper(Short.class)); - assertTrue("Integer.class", ClassUtils.isPrimitiveOrWrapper(Integer.class)); - assertTrue("Long.class", ClassUtils.isPrimitiveOrWrapper(Long.class)); - assertTrue("Double.class", ClassUtils.isPrimitiveOrWrapper(Double.class)); - assertTrue("Float.class", ClassUtils.isPrimitiveOrWrapper(Float.class)); + assertTrue(ClassUtils.isPrimitiveOrWrapper(Boolean.class), "Boolean.class"); + assertTrue(ClassUtils.isPrimitiveOrWrapper(Byte.class), "Byte.class"); + assertTrue(ClassUtils.isPrimitiveOrWrapper(Character.class), "Character.class"); + assertTrue(ClassUtils.isPrimitiveOrWrapper(Short.class), "Short.class"); + assertTrue(ClassUtils.isPrimitiveOrWrapper(Integer.class), "Integer.class"); + assertTrue(ClassUtils.isPrimitiveOrWrapper(Long.class), "Long.class"); + assertTrue(ClassUtils.isPrimitiveOrWrapper(Double.class), "Double.class"); + assertTrue(ClassUtils.isPrimitiveOrWrapper(Float.class), "Float.class"); // test primitive classes - assertTrue("boolean", ClassUtils.isPrimitiveOrWrapper(Boolean.TYPE)); - assertTrue("byte", ClassUtils.isPrimitiveOrWrapper(Byte.TYPE)); - assertTrue("char", ClassUtils.isPrimitiveOrWrapper(Character.TYPE)); - assertTrue("short", ClassUtils.isPrimitiveOrWrapper(Short.TYPE)); - assertTrue("int", ClassUtils.isPrimitiveOrWrapper(Integer.TYPE)); - assertTrue("long", ClassUtils.isPrimitiveOrWrapper(Long.TYPE)); - assertTrue("double", ClassUtils.isPrimitiveOrWrapper(Double.TYPE)); - assertTrue("float", ClassUtils.isPrimitiveOrWrapper(Float.TYPE)); - assertTrue("Void.TYPE", ClassUtils.isPrimitiveOrWrapper(Void.TYPE)); + assertTrue(ClassUtils.isPrimitiveOrWrapper(Boolean.TYPE), "boolean"); + assertTrue(ClassUtils.isPrimitiveOrWrapper(Byte.TYPE), "byte"); + assertTrue(ClassUtils.isPrimitiveOrWrapper(Character.TYPE), "char"); + assertTrue(ClassUtils.isPrimitiveOrWrapper(Short.TYPE), "short"); + assertTrue(ClassUtils.isPrimitiveOrWrapper(Integer.TYPE), "int"); + assertTrue(ClassUtils.isPrimitiveOrWrapper(Long.TYPE), "long"); + assertTrue(ClassUtils.isPrimitiveOrWrapper(Double.TYPE), "double"); + assertTrue(ClassUtils.isPrimitiveOrWrapper(Float.TYPE), "float"); + assertTrue(ClassUtils.isPrimitiveOrWrapper(Void.TYPE), "Void.TYPE"); // others - assertFalse("null", ClassUtils.isPrimitiveOrWrapper(null)); - assertFalse("Void.class", ClassUtils.isPrimitiveOrWrapper(Void.class)); - assertFalse("String.class", ClassUtils.isPrimitiveOrWrapper(String.class)); - assertFalse("this.getClass()", ClassUtils.isPrimitiveOrWrapper(this.getClass())); + assertFalse(ClassUtils.isPrimitiveOrWrapper(null), "null"); + assertFalse(ClassUtils.isPrimitiveOrWrapper(Void.class), "Void.class"); + assertFalse(ClassUtils.isPrimitiveOrWrapper(String.class), "String.class"); + assertFalse(ClassUtils.isPrimitiveOrWrapper(this.getClass()), "this.getClass()"); } @Test public void testIsPrimitiveWrapper() { // test primitive wrapper classes - assertTrue("Boolean.class", ClassUtils.isPrimitiveWrapper(Boolean.class)); - assertTrue("Byte.class", ClassUtils.isPrimitiveWrapper(Byte.class)); - assertTrue("Character.class", ClassUtils.isPrimitiveWrapper(Character.class)); - assertTrue("Short.class", ClassUtils.isPrimitiveWrapper(Short.class)); - assertTrue("Integer.class", ClassUtils.isPrimitiveWrapper(Integer.class)); - assertTrue("Long.class", ClassUtils.isPrimitiveWrapper(Long.class)); - assertTrue("Double.class", ClassUtils.isPrimitiveWrapper(Double.class)); - assertTrue("Float.class", ClassUtils.isPrimitiveWrapper(Float.class)); + assertTrue(ClassUtils.isPrimitiveWrapper(Boolean.class), "Boolean.class"); + assertTrue(ClassUtils.isPrimitiveWrapper(Byte.class), "Byte.class"); + assertTrue(ClassUtils.isPrimitiveWrapper(Character.class), "Character.class"); + assertTrue(ClassUtils.isPrimitiveWrapper(Short.class), "Short.class"); + assertTrue(ClassUtils.isPrimitiveWrapper(Integer.class), "Integer.class"); + assertTrue(ClassUtils.isPrimitiveWrapper(Long.class), "Long.class"); + assertTrue(ClassUtils.isPrimitiveWrapper(Double.class), "Double.class"); + assertTrue(ClassUtils.isPrimitiveWrapper(Float.class), "Float.class"); // test primitive classes - assertFalse("boolean", ClassUtils.isPrimitiveWrapper(Boolean.TYPE)); - assertFalse("byte", ClassUtils.isPrimitiveWrapper(Byte.TYPE)); - assertFalse("char", ClassUtils.isPrimitiveWrapper(Character.TYPE)); - assertFalse("short", ClassUtils.isPrimitiveWrapper(Short.TYPE)); - assertFalse("int", ClassUtils.isPrimitiveWrapper(Integer.TYPE)); - assertFalse("long", ClassUtils.isPrimitiveWrapper(Long.TYPE)); - assertFalse("double", ClassUtils.isPrimitiveWrapper(Double.TYPE)); - assertFalse("float", ClassUtils.isPrimitiveWrapper(Float.TYPE)); + assertFalse(ClassUtils.isPrimitiveWrapper(Boolean.TYPE), "boolean"); + assertFalse(ClassUtils.isPrimitiveWrapper(Byte.TYPE), "byte"); + assertFalse(ClassUtils.isPrimitiveWrapper(Character.TYPE), "char"); + assertFalse(ClassUtils.isPrimitiveWrapper(Short.TYPE), "short"); + assertFalse(ClassUtils.isPrimitiveWrapper(Integer.TYPE), "int"); + assertFalse(ClassUtils.isPrimitiveWrapper(Long.TYPE), "long"); + assertFalse(ClassUtils.isPrimitiveWrapper(Double.TYPE), "double"); + assertFalse(ClassUtils.isPrimitiveWrapper(Float.TYPE), "float"); // others - assertFalse("null", ClassUtils.isPrimitiveWrapper(null)); - assertFalse("Void.class", ClassUtils.isPrimitiveWrapper(Void.class)); - assertFalse("Void.TYPE", ClassUtils.isPrimitiveWrapper(Void.TYPE)); - assertFalse("String.class", ClassUtils.isPrimitiveWrapper(String.class)); - assertFalse("this.getClass()", ClassUtils.isPrimitiveWrapper(this.getClass())); + assertFalse(ClassUtils.isPrimitiveWrapper(null), "null"); + assertFalse(ClassUtils.isPrimitiveWrapper(Void.class), "Void.class"); + assertFalse(ClassUtils.isPrimitiveWrapper(Void.TYPE), "Void.TYPE"); + assertFalse(ClassUtils.isPrimitiveWrapper(String.class), "String.class"); + assertFalse(ClassUtils.isPrimitiveWrapper(this.getClass()), "this.getClass()"); } @Test public void testPrimitivesToWrappers() { // test null // assertNull("null -> null", ClassUtils.primitivesToWrappers(null)); // generates warning - assertNull("null -> null", ClassUtils.primitivesToWrappers((Class[]) null)); // equivalent cast to avoid warning + assertNull(ClassUtils.primitivesToWrappers((Class[]) null), "null -> null"); // equivalent cast to avoid warning // Other possible casts for null - assertTrue("empty -> empty", Arrays.equals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.primitivesToWrappers())); + assertTrue(Arrays.equals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.primitivesToWrappers()), "empty -> empty"); final Class[] castNull = ClassUtils.primitivesToWrappers((Class)null); // == new Class[]{null} - assertTrue("(Class)null -> [null]", Arrays.equals(new Class[]{null}, castNull)); + assertTrue(Arrays.equals(new Class[]{null}, castNull), "(Class)null -> [null]"); // test empty array is returned unchanged - assertArrayEquals("empty -> empty", - ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.primitivesToWrappers(ArrayUtils.EMPTY_CLASS_ARRAY)); + assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.primitivesToWrappers(ArrayUtils.EMPTY_CLASS_ARRAY), + "empty -> empty"); // test an array of various classes final Class[] primitives = new Class[] { @@ -1328,7 +1329,7 @@ public class ClassUtilsTest { final Class primitive = primitives[i]; final Class expectedWrapper = ClassUtils.primitiveToWrapper(primitive); - assertEquals(primitive + " -> " + expectedWrapper, expectedWrapper, wrappers[i]); + assertEquals(expectedWrapper, wrappers[i], primitive + " -> " + expectedWrapper); } // test an array of no primitive classes @@ -1336,42 +1337,30 @@ public class ClassUtilsTest { String.class, ClassUtils.class, Void.TYPE }; // This used to return the exact same array, but no longer does. - assertNotSame("unmodified", noPrimitives, ClassUtils.primitivesToWrappers(noPrimitives)); + assertNotSame(noPrimitives, ClassUtils.primitivesToWrappers(noPrimitives), "unmodified"); } @Test public void testPrimitiveToWrapper() { // test primitive classes - assertEquals("boolean -> Boolean.class", - Boolean.class, ClassUtils.primitiveToWrapper(Boolean.TYPE)); - assertEquals("byte -> Byte.class", - Byte.class, ClassUtils.primitiveToWrapper(Byte.TYPE)); - assertEquals("char -> Character.class", - Character.class, ClassUtils.primitiveToWrapper(Character.TYPE)); - assertEquals("short -> Short.class", - Short.class, ClassUtils.primitiveToWrapper(Short.TYPE)); - assertEquals("int -> Integer.class", - Integer.class, ClassUtils.primitiveToWrapper(Integer.TYPE)); - assertEquals("long -> Long.class", - Long.class, ClassUtils.primitiveToWrapper(Long.TYPE)); - assertEquals("double -> Double.class", - Double.class, ClassUtils.primitiveToWrapper(Double.TYPE)); - assertEquals("float -> Float.class", - Float.class, ClassUtils.primitiveToWrapper(Float.TYPE)); + assertEquals(Boolean.class, ClassUtils.primitiveToWrapper(Boolean.TYPE), "boolean -> Boolean.class"); + assertEquals(Byte.class, ClassUtils.primitiveToWrapper(Byte.TYPE), "byte -> Byte.class"); + assertEquals(Character.class, ClassUtils.primitiveToWrapper(Character.TYPE), "char -> Character.class"); + assertEquals(Short.class, ClassUtils.primitiveToWrapper(Short.TYPE), "short -> Short.class"); + assertEquals(Integer.class, ClassUtils.primitiveToWrapper(Integer.TYPE), "int -> Integer.class"); + assertEquals(Long.class, ClassUtils.primitiveToWrapper(Long.TYPE), "long -> Long.class"); + assertEquals(Double.class, ClassUtils.primitiveToWrapper(Double.TYPE), "double -> Double.class"); + assertEquals(Float.class, ClassUtils.primitiveToWrapper(Float.TYPE), "float -> Float.class"); // test a few other classes - assertEquals("String.class -> String.class", - String.class, ClassUtils.primitiveToWrapper(String.class)); - assertEquals("ClassUtils.class -> ClassUtils.class", - org.apache.commons.lang3.ClassUtils.class, - ClassUtils.primitiveToWrapper(org.apache.commons.lang3.ClassUtils.class)); - assertEquals("Void.TYPE -> Void.TYPE", - Void.TYPE, ClassUtils.primitiveToWrapper(Void.TYPE)); + assertEquals(String.class, ClassUtils.primitiveToWrapper(String.class), "String.class -> String.class"); + assertEquals(ClassUtils.class, ClassUtils.primitiveToWrapper(ClassUtils.class), + "ClassUtils.class -> ClassUtils.class"); + assertEquals(Void.TYPE, ClassUtils.primitiveToWrapper(Void.TYPE), "Void.TYPE -> Void.TYPE"); // test null - assertNull("null -> null", - ClassUtils.primitiveToWrapper(null)); + assertNull(ClassUtils.primitiveToWrapper(null), "null -> null"); } // Show the Java bug: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4071957 @@ -1395,9 +1384,9 @@ public class ClassUtilsTest { assertNull(ClassUtils.toClass((Object[]) null)); // equivalent explicit cast // Additional varargs tests - assertTrue("empty -> empty", Arrays.equals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.toClass())); + assertTrue(Arrays.equals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.toClass()), "empty -> empty"); final Class[] castNull = ClassUtils.toClass((Object) null); // == new Object[]{null} - assertTrue("(Object)null -> [null]", Arrays.equals(new Object[]{null}, castNull)); + assertTrue(Arrays.equals(new Object[]{null}, castNull), "(Object)null -> [null]"); assertSame(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.toClass(ArrayUtils.EMPTY_OBJECT_ARRAY)); @@ -1427,28 +1416,27 @@ public class ClassUtilsTest { final Class[] primitives = ClassUtils.wrappersToPrimitives(classes); // now test the result - assertEquals("Wrong length of result array", classes.length, primitives.length); + assertEquals(classes.length, primitives.length, "Wrong length of result array"); for (int i = 0; i < classes.length; i++) { final Class expectedPrimitive = ClassUtils.wrapperToPrimitive(classes[i]); - assertEquals(classes[i] + " -> " + expectedPrimitive, expectedPrimitive, - primitives[i]); + assertEquals(expectedPrimitive, primitives[i], classes[i] + " -> " + expectedPrimitive); } } @Test public void testWrappersToPrimitivesEmpty() { final Class[] empty = new Class[0]; - assertArrayEquals("Wrong result for empty input", empty, ClassUtils.wrappersToPrimitives(empty)); + assertArrayEquals(empty, ClassUtils.wrappersToPrimitives(empty), "Wrong result for empty input"); } @Test public void testWrappersToPrimitivesNull() { // assertNull("Wrong result for null input", ClassUtils.wrappersToPrimitives(null)); // generates warning - assertNull("Wrong result for null input", ClassUtils.wrappersToPrimitives((Class[]) null)); // equivalent cast + assertNull(ClassUtils.wrappersToPrimitives((Class[]) null), "Wrong result for null input"); // equivalent cast // Other possible casts for null - assertTrue("empty -> empty", Arrays.equals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.wrappersToPrimitives())); + assertTrue(Arrays.equals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.wrappersToPrimitives()), "empty -> empty"); final Class[] castNull = ClassUtils.wrappersToPrimitives((Class)null); // == new Class[]{null} - assertTrue("(Class)null -> [null]", Arrays.equals(new Class[]{null}, castNull)); + assertTrue(Arrays.equals(new Class[]{null}, castNull), "(Class)null -> [null]"); } @Test @@ -1460,19 +1448,18 @@ public class ClassUtilsTest { }; for (final Class primitive : primitives) { final Class wrapperCls = ClassUtils.primitiveToWrapper(primitive); - assertFalse("Still primitive", wrapperCls.isPrimitive()); - assertEquals(wrapperCls + " -> " + primitive, primitive, - ClassUtils.wrapperToPrimitive(wrapperCls)); + assertFalse(wrapperCls.isPrimitive(), "Still primitive"); + assertEquals(primitive, ClassUtils.wrapperToPrimitive(wrapperCls), wrapperCls + " -> " + primitive); } } @Test public void testWrapperToPrimitiveNoWrapper() { - assertNull("Wrong result for non wrapper class", ClassUtils.wrapperToPrimitive(String.class)); + assertNull(ClassUtils.wrapperToPrimitive(String.class), "Wrong result for non wrapper class"); } @Test public void testWrapperToPrimitiveNull() { - assertNull("Wrong result for null class", ClassUtils.wrapperToPrimitive(null)); + assertNull(ClassUtils.wrapperToPrimitive(null), "Wrong result for null class"); } } diff --git a/src/test/java/org/apache/commons/lang3/ConversionTest.java b/src/test/java/org/apache/commons/lang3/ConversionTest.java index 3c2a31e04..6c9ca3b09 100644 --- a/src/test/java/org/apache/commons/lang3/ConversionTest.java +++ b/src/test/java/org/apache/commons/lang3/ConversionTest.java @@ -16,13 +16,13 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.fail; import java.util.UUID; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** @@ -519,7 +519,7 @@ public class ConversionTest { return out.substring(0, out.length() - 1); } - // org.junit.Assert(boolean[], boolean[]) does not exist in JUnit 4.2 + // org.junit.jupiter.api.Assertions(boolean[], boolean[]) does not exist in JUnit 4.2 static void assertBinaryEquals(final boolean[] expected, final boolean[] actual) { assertEquals(expected.length, actual.length); for (int i = 0; i < expected.length; i++ ) { diff --git a/src/test/java/org/apache/commons/lang3/EnumUtilsTest.java b/src/test/java/org/apache/commons/lang3/EnumUtilsTest.java index 2b9dc085c..8cf13b44e 100644 --- a/src/test/java/org/apache/commons/lang3/EnumUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/EnumUtilsTest.java @@ -18,10 +18,11 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; +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.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.ArrayList; import java.util.Arrays; @@ -29,8 +30,8 @@ import java.util.EnumSet; import java.util.List; import java.util.Map; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; /** * @@ -46,7 +47,7 @@ public class EnumUtilsTest { @Test public void test_getEnumMap() { final Map test = EnumUtils.getEnumMap(Traffic.class); - assertEquals( "getEnumMap not created correctly", "{RED=RED, AMBER=AMBER, GREEN=GREEN}", test.toString()); + assertEquals("{RED=RED, AMBER=AMBER, GREEN=GREEN}", test.toString(), "getEnumMap not created correctly"); assertEquals(3, test.size()); assertTrue(test.containsKey("RED")); assertEquals(Traffic.RED, test.get("RED")); @@ -75,9 +76,9 @@ public class EnumUtilsTest { assertFalse(EnumUtils.isValidEnum(Traffic.class, null)); } - @Test(expected=NullPointerException.class) + @Test public void test_isValidEnum_nullClass() { - EnumUtils.isValidEnum(null, "PURPLE"); + assertThrows(NullPointerException.class, () -> EnumUtils.isValidEnum(null, "PURPLE")); } @Test @@ -89,9 +90,9 @@ public class EnumUtilsTest { assertFalse(EnumUtils.isValidEnumIgnoreCase(Traffic.class, null)); } - @Test(expected=NullPointerException.class) + @Test public void test_isValidEnumIgnoreCase_nullClass() { - EnumUtils.isValidEnumIgnoreCase(null, "PURPLE"); + assertThrows(NullPointerException.class, () -> EnumUtils.isValidEnumIgnoreCase(null, "PURPLE")); } @Test @@ -109,9 +110,9 @@ public class EnumUtilsTest { assertNull(EnumUtils.getEnum(rawType, "rawType")); } - @Test(expected=NullPointerException.class) + @Test public void test_getEnum_nullClass() { - EnumUtils.getEnum((Class) null, "PURPLE"); + assertThrows(NullPointerException.class, () -> EnumUtils.getEnum((Class) null, "PURPLE")); } @Test @@ -129,83 +130,89 @@ public class EnumUtilsTest { assertNull(EnumUtils.getEnumIgnoreCase(rawType, "rawType")); } - @Test(expected=NullPointerException.class) + @Test public void test_getEnumIgnoreCase_nullClass() { - EnumUtils.getEnumIgnoreCase((Class) null, "PURPLE"); + assertThrows(NullPointerException.class, () -> EnumUtils.getEnumIgnoreCase((Class) null, "PURPLE")); } - @Test(expected=NullPointerException.class) + @Test public void test_generateBitVector_nullClass() { - EnumUtils.generateBitVector(null, EnumSet.of(Traffic.RED)); + assertThrows(NullPointerException.class, () -> EnumUtils.generateBitVector(null, EnumSet.of(Traffic.RED))); } - @Test(expected=NullPointerException.class) + @Test public void test_generateBitVectors_nullClass() { - EnumUtils.generateBitVectors(null, EnumSet.of(Traffic.RED)); + assertThrows(NullPointerException.class, () -> EnumUtils.generateBitVectors(null, EnumSet.of(Traffic.RED))); } - @Test(expected=NullPointerException.class) + @Test public void test_generateBitVector_nullIterable() { - EnumUtils.generateBitVector(Traffic.class, (Iterable) null); + assertThrows(NullPointerException.class, + () -> EnumUtils.generateBitVector(Traffic.class, (Iterable) null)); } - @Test(expected=NullPointerException.class) + @Test public void test_generateBitVectors_nullIterable() { - EnumUtils.generateBitVectors(null, (Iterable) null); + assertThrows(NullPointerException.class, () -> EnumUtils.generateBitVectors(null, (Iterable) null)); } - @Test(expected=IllegalArgumentException.class) + @Test public void test_generateBitVector_nullElement() { - EnumUtils.generateBitVector(Traffic.class, Arrays.asList(Traffic.RED, null)); + assertThrows(IllegalArgumentException.class, + () -> EnumUtils.generateBitVector(Traffic.class, Arrays.asList(Traffic.RED, null))); } - @Test(expected=IllegalArgumentException.class) + @Test public void test_generateBitVectors_nullElement() { - EnumUtils.generateBitVectors(Traffic.class, Arrays.asList(Traffic.RED, null)); + assertThrows(IllegalArgumentException.class, + () -> EnumUtils.generateBitVectors(Traffic.class, Arrays.asList(Traffic.RED, null))); } - @Test(expected=NullPointerException.class) + @Test public void test_generateBitVector_nullClassWithArray() { - EnumUtils.generateBitVector(null, Traffic.RED); + assertThrows(NullPointerException.class, () -> EnumUtils.generateBitVector(null, Traffic.RED)); } - @Test(expected=NullPointerException.class) + @Test public void test_generateBitVectors_nullClassWithArray() { - EnumUtils.generateBitVectors(null, Traffic.RED); + assertThrows(NullPointerException.class, () -> EnumUtils.generateBitVectors(null, Traffic.RED)); } - @Test(expected=NullPointerException.class) + @Test public void test_generateBitVector_nullArray() { - EnumUtils.generateBitVector(Traffic.class, (Traffic[]) null); + assertThrows(NullPointerException.class, () -> EnumUtils.generateBitVector(Traffic.class, (Traffic[]) null)); } - @Test(expected=NullPointerException.class) + @Test public void test_generateBitVectors_nullArray() { - EnumUtils.generateBitVectors(Traffic.class, (Traffic[]) null); + assertThrows(NullPointerException.class, () -> EnumUtils.generateBitVectors(Traffic.class, (Traffic[]) null)); } - @Test(expected=IllegalArgumentException.class) + @Test public void test_generateBitVector_nullArrayElement() { - EnumUtils.generateBitVector(Traffic.class, Traffic.RED, null); + assertThrows(IllegalArgumentException.class, + () -> EnumUtils.generateBitVector(Traffic.class, Traffic.RED, null)); } - @Test(expected=IllegalArgumentException.class) + @Test public void test_generateBitVectors_nullArrayElement() { - EnumUtils.generateBitVectors(Traffic.class, Traffic.RED, null); + assertThrows(IllegalArgumentException.class, + () -> EnumUtils.generateBitVectors(Traffic.class, Traffic.RED, null)); } - @Test(expected=IllegalArgumentException.class) + @Test public void test_generateBitVector_longClass() { - EnumUtils.generateBitVector(TooMany.class, EnumSet.of(TooMany.A1)); + assertThrows(IllegalArgumentException.class, + () -> EnumUtils.generateBitVector(TooMany.class, EnumSet.of(TooMany.A1))); } - @Test(expected=IllegalArgumentException.class) + @Test public void test_generateBitVector_longClassWithArray() { - EnumUtils.generateBitVector(TooMany.class, TooMany.A1); + assertThrows(IllegalArgumentException.class, () -> EnumUtils.generateBitVector(TooMany.class, TooMany.A1)); } @SuppressWarnings("unchecked") - @Test(expected=IllegalArgumentException.class) + @Test public void test_generateBitVector_nonEnumClass() { @SuppressWarnings("rawtypes") final @@ -213,11 +220,11 @@ public class EnumUtilsTest { @SuppressWarnings("rawtypes") final List rawList = new ArrayList(); - EnumUtils.generateBitVector(rawType, rawList); + assertThrows(IllegalArgumentException.class, () -> EnumUtils.generateBitVector(rawType, rawList)); } @SuppressWarnings("unchecked") - @Test(expected=IllegalArgumentException.class) + @Test public void test_generateBitVectors_nonEnumClass() { @SuppressWarnings("rawtypes") final @@ -225,25 +232,25 @@ public class EnumUtilsTest { @SuppressWarnings("rawtypes") final List rawList = new ArrayList(); - EnumUtils.generateBitVectors(rawType, rawList); + assertThrows(IllegalArgumentException.class, () -> EnumUtils.generateBitVectors(rawType, rawList)); } @SuppressWarnings("unchecked") - @Test(expected=IllegalArgumentException.class) + @Test public void test_generateBitVector_nonEnumClassWithArray() { @SuppressWarnings("rawtypes") final Class rawType = Object.class; - EnumUtils.generateBitVector(rawType); + assertThrows(IllegalArgumentException.class, () -> EnumUtils.generateBitVector(rawType)); } @SuppressWarnings("unchecked") - @Test(expected=IllegalArgumentException.class) + @Test public void test_generateBitVectors_nonEnumClassWithArray() { @SuppressWarnings("rawtypes") final Class rawType = Object.class; - EnumUtils.generateBitVectors(rawType); + assertThrows(IllegalArgumentException.class, () -> EnumUtils.generateBitVectors(rawType)); } @Test @@ -332,19 +339,19 @@ public class EnumUtilsTest { } private void assertArrayEquals(final long[] actual, final long... expected) { - Assert.assertArrayEquals(expected, actual); + Assertions.assertArrayEquals(expected, actual); } - @Test(expected=NullPointerException.class) + @Test public void test_processBitVector_nullClass() { final Class empty = null; - EnumUtils.processBitVector(empty, 0L); + assertThrows(NullPointerException.class, () -> EnumUtils.processBitVector(empty, 0L)); } - @Test(expected=NullPointerException.class) + @Test public void test_processBitVectors_nullClass() { final Class empty = null; - EnumUtils.processBitVectors(empty, 0L); + assertThrows(NullPointerException.class, () -> EnumUtils.processBitVectors(empty, 0L)); } @Test @@ -402,9 +409,9 @@ public class EnumUtilsTest { assertEquals(EnumSet.of(Enum64.A63), EnumUtils.processBitVectors(Enum64.class, Long.MIN_VALUE)); } - @Test(expected=IllegalArgumentException.class) + @Test public void test_processBitVector_longClass() { - EnumUtils.processBitVector(TooMany.class, 0L); + assertThrows(IllegalArgumentException.class, () -> EnumUtils.processBitVector(TooMany.class, 0L)); } @Test diff --git a/src/test/java/org/apache/commons/lang3/JavaVersionTest.java b/src/test/java/org/apache/commons/lang3/JavaVersionTest.java index 7a6cbe297..2bbb3c62e 100644 --- a/src/test/java/org/apache/commons/lang3/JavaVersionTest.java +++ b/src/test/java/org/apache/commons/lang3/JavaVersionTest.java @@ -18,12 +18,12 @@ */ package org.apache.commons.lang3; -import org.junit.Test; +import org.junit.jupiter.api.Test; import static org.apache.commons.lang3.JavaVersion.JAVA_RECENT; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.apache.commons.lang3.JavaVersion.JAVA_0_9; import static org.apache.commons.lang3.JavaVersion.JAVA_1_1; import static org.apache.commons.lang3.JavaVersion.JAVA_1_2; @@ -45,32 +45,32 @@ public class JavaVersionTest { @Test public void testGetJavaVersion() { - assertEquals("0.9 failed", JAVA_0_9, get("0.9")); - assertEquals("1.1 failed", JAVA_1_1, get("1.1")); - assertEquals("1.2 failed", JAVA_1_2, get("1.2")); - assertEquals("1.3 failed", JAVA_1_3, get("1.3")); - assertEquals("1.4 failed", JAVA_1_4, get("1.4")); - assertEquals("1.5 failed", JAVA_1_5, get("1.5")); - assertEquals("1.6 failed", JAVA_1_6, get("1.6")); - assertEquals("1.7 failed", JAVA_1_7, get("1.7")); - assertEquals("1.8 failed", JAVA_1_8, get("1.8")); - assertEquals("9 failed", JAVA_9, get("9")); - assertEquals("10 failed", JAVA_10, get("10")); - assertEquals("11 failed", JavaVersion.JAVA_11, get("11")); - assertEquals("1.10 failed", JAVA_RECENT, get("1.10")); + assertEquals(JAVA_0_9, get("0.9"), "0.9 failed"); + assertEquals(JAVA_1_1, get("1.1"), "1.1 failed"); + assertEquals(JAVA_1_2, get("1.2"), "1.2 failed"); + assertEquals(JAVA_1_3, get("1.3"), "1.3 failed"); + assertEquals(JAVA_1_4, get("1.4"), "1.4 failed"); + assertEquals(JAVA_1_5, get("1.5"), "1.5 failed"); + assertEquals(JAVA_1_6, get("1.6"), "1.6 failed"); + assertEquals(JAVA_1_7, get("1.7"), "1.7 failed"); + assertEquals(JAVA_1_8, get("1.8"), "1.8 failed"); + assertEquals(JAVA_9, get("9"), "9 failed"); + assertEquals(JAVA_10, get("10"), "10 failed"); + assertEquals(JavaVersion.JAVA_11, get("11"), "11 failed"); + assertEquals(JAVA_RECENT, get("1.10"), "1.10 failed"); // assertNull("2.10 unexpectedly worked", get("2.10")); - assertEquals("Wrapper method failed", get("1.5"), getJavaVersion("1.5")); - assertEquals("Unhandled", JAVA_RECENT, get("12")); // LANG-1384 + assertEquals(get("1.5"), getJavaVersion("1.5"), "Wrapper method failed"); + assertEquals(JAVA_RECENT, get("12"), "Unhandled"); // LANG-1384 } @Test public void testAtLeast() { - assertFalse("1.2 at least 1.5 passed", JAVA_1_2.atLeast(JAVA_1_5)); - assertTrue("1.5 at least 1.2 failed", JAVA_1_5.atLeast(JAVA_1_2)); - assertFalse("1.6 at least 1.7 passed", JAVA_1_6.atLeast(JAVA_1_7)); + assertFalse(JAVA_1_2.atLeast(JAVA_1_5), "1.2 at least 1.5 passed"); + assertTrue(JAVA_1_5.atLeast(JAVA_1_2), "1.5 at least 1.2 failed"); + assertFalse(JAVA_1_6.atLeast(JAVA_1_7), "1.6 at least 1.7 passed"); - assertTrue("0.9 at least 1.5 failed", JAVA_0_9.atLeast(JAVA_1_5)); - assertFalse("0.9 at least 1.6 passed", JAVA_0_9.atLeast(JAVA_1_6)); + assertTrue(JAVA_0_9.atLeast(JAVA_1_5), "0.9 at least 1.5 failed"); + assertFalse(JAVA_0_9.atLeast(JAVA_1_6), "0.9 at least 1.6 passed"); } @Test diff --git a/src/test/java/org/apache/commons/lang3/LocaleUtilsTest.java b/src/test/java/org/apache/commons/lang3/LocaleUtilsTest.java index 1c39a7731..edd70167e 100644 --- a/src/test/java/org/apache/commons/lang3/LocaleUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/LocaleUtilsTest.java @@ -17,13 +17,13 @@ package org.apache.commons.lang3; import static org.apache.commons.lang3.JavaVersion.JAVA_1_4; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; import java.lang.reflect.Constructor; import java.lang.reflect.Modifier; @@ -35,8 +35,8 @@ import java.util.List; import java.util.Locale; import java.util.Set; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; /** * Unit tests for {@link LocaleUtils}. @@ -51,7 +51,7 @@ public class LocaleUtilsTest { private static final Locale LOCALE_QQ = new Locale("qq", ""); private static final Locale LOCALE_QQ_ZZ = new Locale("qq", "ZZ"); - @Before + @BeforeEach public void setUp() throws Exception { // Testing #LANG-304. Must be called before availableLocaleSet is called. LocaleUtils.isAvailableLocale(Locale.getDefault()); @@ -79,7 +79,7 @@ public class LocaleUtilsTest { */ private static void assertValidToLocale(final String language) { final Locale locale = LocaleUtils.toLocale(language); - assertNotNull("valid locale", locale); + assertNotNull(locale, "valid locale"); assertEquals(language, locale.getLanguage()); //country and variant are empty assertTrue(locale.getCountry() == null || locale.getCountry().isEmpty()); @@ -95,7 +95,7 @@ public class LocaleUtilsTest { */ private static void assertValidToLocale(final String localeString, final String language, final String country) { final Locale locale = LocaleUtils.toLocale(localeString); - assertNotNull("valid locale", locale); + assertNotNull(locale, "valid locale"); assertEquals(language, locale.getLanguage()); assertEquals(country, locale.getCountry()); //variant is empty @@ -114,7 +114,7 @@ public class LocaleUtilsTest { final String localeString, final String language, final String country, final String variant) { final Locale locale = LocaleUtils.toLocale(localeString); - assertNotNull("valid locale", locale); + assertNotNull(locale, "valid locale"); assertEquals(language, locale.getLanguage()); assertEquals(country, locale.getCountry()); assertEquals(variant, locale.getVariant()); diff --git a/src/test/java/org/apache/commons/lang3/NotImplementedExceptionTest.java b/src/test/java/org/apache/commons/lang3/NotImplementedExceptionTest.java index 86f4fab8d..77f763851 100644 --- a/src/test/java/org/apache/commons/lang3/NotImplementedExceptionTest.java +++ b/src/test/java/org/apache/commons/lang3/NotImplementedExceptionTest.java @@ -16,9 +16,9 @@ */ package org.apache.commons.lang3; -import org.junit.Test; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; /** * Unit tests {@link org.apache.commons.lang3.NotImplementedException}. @@ -46,9 +46,9 @@ public class NotImplementedExceptionTest { } private void assertCorrect(final String assertMessage, final NotImplementedException nie, final String message, final Throwable nested, final String code) { - assertNotNull(assertMessage + ": target is null", nie); - assertEquals(assertMessage + ": Message not equal", message, nie.getMessage()); - assertEquals(assertMessage + ": Nested throwable not equal", nested, nie.getCause()); - assertEquals(assertMessage + ": Code not equal", code, nie.getCode()); + assertNotNull(nie, assertMessage + ": target is null"); + assertEquals(message, nie.getMessage(), assertMessage + ": Message not equal"); + assertEquals(nested, nie.getCause(), assertMessage + ": Nested throwable not equal"); + assertEquals(code, nie.getCode(), assertMessage + ": Code not equal"); } } diff --git a/src/test/java/org/apache/commons/lang3/ObjectUtilsTest.java b/src/test/java/org/apache/commons/lang3/ObjectUtilsTest.java index e12ac3fbe..5c902c79f 100644 --- a/src/test/java/org/apache/commons/lang3/ObjectUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/ObjectUtilsTest.java @@ -16,14 +16,15 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNotSame; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +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.IOException; import java.lang.reflect.Constructor; @@ -43,7 +44,7 @@ import java.util.Set; import org.apache.commons.lang3.exception.CloneFailedException; import org.apache.commons.lang3.mutable.MutableObject; import org.apache.commons.lang3.text.StrBuilder; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Unit tests {@link org.apache.commons.lang3.ObjectUtils}. @@ -111,8 +112,8 @@ public class ObjectUtilsTest { public void testIsNull() { final Object o = FOO; final Object dflt = BAR; - assertSame("dflt was not returned when o was null", dflt, ObjectUtils.defaultIfNull(null, dflt)); - assertSame("dflt was returned when o was not null", o, ObjectUtils.defaultIfNull(o, dflt)); + assertSame(dflt, ObjectUtils.defaultIfNull(null, dflt), "dflt was not returned when o was null"); + assertSame(o, ObjectUtils.defaultIfNull(o, dflt), "dflt was returned when o was not null"); } @Test @@ -168,20 +169,20 @@ public class ObjectUtilsTest { //----------------------------------------------------------------------- @Test public void testEquals() { - assertTrue("ObjectUtils.equals(null, null) returned false", ObjectUtils.equals(null, null)); - assertTrue("ObjectUtils.equals(\"foo\", null) returned true", !ObjectUtils.equals(FOO, null)); - assertTrue("ObjectUtils.equals(null, \"bar\") returned true", !ObjectUtils.equals(null, BAR)); - assertTrue("ObjectUtils.equals(\"foo\", \"bar\") returned true", !ObjectUtils.equals(FOO, BAR)); - assertTrue("ObjectUtils.equals(\"foo\", \"foo\") returned false", ObjectUtils.equals(FOO, FOO)); + assertTrue(ObjectUtils.equals(null, null), "ObjectUtils.equals(null, null) returned false"); + assertTrue(!ObjectUtils.equals(FOO, null), "ObjectUtils.equals(\"foo\", null) returned true"); + assertTrue(!ObjectUtils.equals(null, BAR), "ObjectUtils.equals(null, \"bar\") returned true"); + assertTrue(!ObjectUtils.equals(FOO, BAR), "ObjectUtils.equals(\"foo\", \"bar\") returned true"); + assertTrue(ObjectUtils.equals(FOO, FOO), "ObjectUtils.equals(\"foo\", \"foo\") returned false"); } @Test public void testNotEqual() { - assertFalse("ObjectUtils.notEqual(null, null) returned false", ObjectUtils.notEqual(null, null)); - assertTrue("ObjectUtils.notEqual(\"foo\", null) returned true", ObjectUtils.notEqual(FOO, null)); - assertTrue("ObjectUtils.notEqual(null, \"bar\") returned true", ObjectUtils.notEqual(null, BAR)); - assertTrue("ObjectUtils.notEqual(\"foo\", \"bar\") returned true", ObjectUtils.notEqual(FOO, BAR)); - assertFalse("ObjectUtils.notEqual(\"foo\", \"foo\") returned false", ObjectUtils.notEqual(FOO, FOO)); + assertFalse(ObjectUtils.notEqual(null, null), "ObjectUtils.notEqual(null, null) returned false"); + assertTrue(ObjectUtils.notEqual(FOO, null), "ObjectUtils.notEqual(\"foo\", null) returned true"); + assertTrue(ObjectUtils.notEqual(null, BAR), "ObjectUtils.notEqual(null, \"bar\") returned true"); + assertTrue(ObjectUtils.notEqual(FOO, BAR), "ObjectUtils.notEqual(\"foo\", \"bar\") returned true"); + assertFalse(ObjectUtils.notEqual(FOO, FOO), "ObjectUtils.notEqual(\"foo\", \"foo\") returned false"); } @Test @@ -430,17 +431,17 @@ public class ObjectUtilsTest { final Integer two = Integer.valueOf(2); final Integer nullValue = null; - assertEquals("Null Null false", 0, ObjectUtils.compare(nullValue, nullValue)); - assertEquals("Null Null true", 0, ObjectUtils.compare(nullValue, nullValue, true)); + assertEquals(0, ObjectUtils.compare(nullValue, nullValue), "Null Null false"); + assertEquals(0, ObjectUtils.compare(nullValue, nullValue, true), "Null Null true"); - assertEquals("Null one false", -1, ObjectUtils.compare(nullValue, one)); - assertEquals("Null one true", 1, ObjectUtils.compare(nullValue, one, true)); + assertEquals(-1, ObjectUtils.compare(nullValue, one), "Null one false"); + assertEquals(1, ObjectUtils.compare(nullValue, one, true), "Null one true"); - assertEquals("one Null false", 1, ObjectUtils.compare(one, nullValue)); - assertEquals("one Null true", -1, ObjectUtils.compare(one, nullValue, true)); + assertEquals(1, ObjectUtils.compare(one, nullValue), "one Null false"); + assertEquals(-1, ObjectUtils.compare(one, nullValue, true), "one Null true"); - assertEquals("one two false", -1, ObjectUtils.compare(one, two)); - assertEquals("one two true", -1, ObjectUtils.compare(one, two, true)); + assertEquals(-1, ObjectUtils.compare(one, two), "one two false"); + assertEquals(-1, ObjectUtils.compare(one, two, true), "one two true"); } @Test @@ -460,14 +461,14 @@ public class ObjectUtilsTest { ObjectUtils.median(Integer.valueOf(5), Integer.valueOf(6), Integer.valueOf(7), Integer.valueOf(8))); } - @Test(expected = NullPointerException.class) + @Test public void testMedian_nullItems() { - ObjectUtils.median((String[]) null); + assertThrows(NullPointerException.class, () -> ObjectUtils.median((String[]) null)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testMedian_emptyItems() { - ObjectUtils. median(); + assertThrows(IllegalArgumentException.class, ObjectUtils::median); } @Test @@ -485,19 +486,21 @@ public class ObjectUtilsTest { assertSame(blah, ObjectUtils.median(cmp, foo, bar, baz, blah, wah)); } - @Test(expected = NullPointerException.class) + @Test public void testComparatorMedian_nullComparator() { - ObjectUtils.median((Comparator) null, new NonComparableCharSequence("foo")); + assertThrows(NullPointerException.class, + () -> ObjectUtils.median((Comparator) null, new NonComparableCharSequence("foo"))); } - @Test(expected = NullPointerException.class) + @Test public void testComparatorMedian_nullItems() { - ObjectUtils.median(new CharSequenceComparator(), (CharSequence[]) null); + assertThrows(NullPointerException.class, + () -> ObjectUtils.median(new CharSequenceComparator(), (CharSequence[]) null)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testComparatorMedian_emptyItems() { - ObjectUtils.median(new CharSequenceComparator()); + assertThrows(IllegalArgumentException.class, () -> ObjectUtils.median(new CharSequenceComparator())); } @Test @@ -532,18 +535,12 @@ public class ObjectUtilsTest { /** * Tests {@link ObjectUtils#clone(Object)} with an uncloneable object. - * - * @throws java.lang.Throwable because we expect this to fail */ - @Test(expected = NoSuchMethodException.class) - public void testCloneOfUncloneable() throws Throwable { + @Test + public void testCloneOfUncloneable() { final UncloneableString string = new UncloneableString("apache"); - try { - ObjectUtils.clone(string); - fail("Thrown " + CloneFailedException.class.getName() + " expected"); - } catch (final CloneFailedException e) { - throw e.getCause(); - } + CloneFailedException e = assertThrows(CloneFailedException.class, () -> ObjectUtils.clone(string)); + assertEquals(NoSuchMethodException.class, e.getCause().getClass()); } /** @@ -584,18 +581,12 @@ public class ObjectUtilsTest { /** * Tests {@link ObjectUtils#cloneIfPossible(Object)} with an uncloneable object. - * - * @throws java.lang.Throwable because we expect this to fail */ - @Test(expected = NoSuchMethodException.class) - public void testPossibleCloneOfUncloneable() throws Throwable { + @Test + public void testPossibleCloneOfUncloneable() { final UncloneableString string = new UncloneableString("apache"); - try { - ObjectUtils.cloneIfPossible(string); - fail("Thrown " + CloneFailedException.class.getName() + " expected"); - } catch (final CloneFailedException e) { - throw e.getCause(); - } + CloneFailedException e = assertThrows(CloneFailedException.class, () -> ObjectUtils.cloneIfPossible(string)); + assertEquals(NoSuchMethodException.class, e.getCause().getClass()); } @Test @@ -605,15 +596,18 @@ public class ObjectUtilsTest { // bytecode to see if the literals were folded into the // class, or if the bytecode kept the method call. - assertTrue("CONST(boolean)", ObjectUtils.CONST(true)); - assertEquals("CONST(byte)", (byte) 3, ObjectUtils.CONST((byte) 3)); - assertEquals("CONST(char)", (char) 3, ObjectUtils.CONST((char) 3)); - assertEquals("CONST(short)", (short) 3, ObjectUtils.CONST((short) 3)); - assertEquals("CONST(int)", 3, ObjectUtils.CONST(3)); - assertEquals("CONST(long)", 3L, ObjectUtils.CONST(3L)); - assertEquals("CONST(float)", 3f, ObjectUtils.CONST(3f), 0); - assertEquals("CONST(double)", 3.0, ObjectUtils.CONST(3.0), 0); - assertEquals("CONST(Object)", "abc", ObjectUtils.CONST("abc")); + // TODO: JUnit Jupiter 5.3.1 doesn't support delta=0. + // This should be replaced when it is supported in JUnit Jupiter 5.4. + // See https://github.com/junit-team/junit5/pull/1613 for details. + assertTrue(ObjectUtils.CONST(true), "CONST(boolean)"); + assertEquals((byte) 3, ObjectUtils.CONST((byte) 3), "CONST(byte)"); + assertEquals((char) 3, ObjectUtils.CONST((char) 3), "CONST(char)"); + assertEquals((short) 3, ObjectUtils.CONST((short) 3), "CONST(short)"); + assertEquals(3, ObjectUtils.CONST(3), "CONST(int)"); + assertEquals(3L, ObjectUtils.CONST(3L), "CONST(long)"); + assertTrue(3f == ObjectUtils.CONST(3f), "CONST(float)"); + assertTrue(3.0 == ObjectUtils.CONST(3.0), "CONST(double)"); + assertEquals("abc", ObjectUtils.CONST("abc"), "CONST(Object)"); // Make sure documentation examples from Javadoc all work // (this fixed a lot of my bugs when I these!) @@ -644,8 +638,8 @@ public class ObjectUtilsTest { assertEquals(123, MAGIC_INT); assertEquals(123, MAGIC_LONG1); assertEquals(3, MAGIC_LONG2); - assertEquals(1.0f, MAGIC_FLOAT, 0.0f); - assertEquals(1.0, MAGIC_DOUBLE, 0.0); + assertTrue(1.0f == MAGIC_FLOAT); + assertTrue(1.0 == MAGIC_DOUBLE); assertEquals("abc", MAGIC_STRING); try { diff --git a/src/test/java/org/apache/commons/lang3/RandomStringUtilsTest.java b/src/test/java/org/apache/commons/lang3/RandomStringUtilsTest.java index 850ba380b..6ab3cec7a 100644 --- a/src/test/java/org/apache/commons/lang3/RandomStringUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/RandomStringUtilsTest.java @@ -16,23 +16,23 @@ */ package org.apache.commons.lang3; +import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.allOf; import static org.hamcrest.Matchers.greaterThanOrEqualTo; import static org.hamcrest.Matchers.is; import static org.hamcrest.Matchers.lessThanOrEqualTo; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertThat; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; import java.lang.reflect.Constructor; import java.lang.reflect.Modifier; import java.nio.charset.Charset; import java.util.Random; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Unit tests {@link org.apache.commons.lang3.RandomStringUtils}. @@ -57,96 +57,96 @@ public class RandomStringUtilsTest { @Test public void testRandomStringUtils() { String r1 = RandomStringUtils.random(50); - assertEquals("random(50) length", 50, r1.length()); + assertEquals(50, r1.length(), "random(50) length"); String r2 = RandomStringUtils.random(50); - assertEquals("random(50) length", 50, r2.length()); - assertTrue("!r1.equals(r2)", !r1.equals(r2)); + assertEquals(50, r2.length(), "random(50) length"); + assertTrue(!r1.equals(r2), "!r1.equals(r2)"); r1 = RandomStringUtils.randomAscii(50); - assertEquals("randomAscii(50) length", 50, r1.length()); + assertEquals(50, r1.length(), "randomAscii(50) length"); for(int i = 0; i < r1.length(); i++) { - assertTrue("char between 32 and 127", r1.charAt(i) >= 32 && r1.charAt(i) <= 127); + assertTrue(r1.charAt(i) >= 32 && r1.charAt(i) <= 127, "char between 32 and 127"); } r2 = RandomStringUtils.randomAscii(50); - assertTrue("!r1.equals(r2)", !r1.equals(r2)); + assertTrue(!r1.equals(r2), "!r1.equals(r2)"); r1 = RandomStringUtils.randomAlphabetic(50); - assertEquals("randomAlphabetic(50)", 50, r1.length()); + assertEquals(50, r1.length(), "randomAlphabetic(50)"); for(int i = 0; i < r1.length(); i++) { - assertTrue("r1 contains alphabetic", Character.isLetter(r1.charAt(i)) && !Character.isDigit(r1.charAt(i))); + assertTrue(Character.isLetter(r1.charAt(i)) && !Character.isDigit(r1.charAt(i)), "r1 contains alphabetic"); } r2 = RandomStringUtils.randomAlphabetic(50); - assertTrue("!r1.equals(r2)", !r1.equals(r2)); + assertTrue(!r1.equals(r2), "!r1.equals(r2)"); r1 = RandomStringUtils.randomAlphanumeric(50); - assertEquals("randomAlphanumeric(50)", 50, r1.length()); + assertEquals(50, r1.length(), "randomAlphanumeric(50)"); for(int i = 0; i < r1.length(); i++) { - assertTrue("r1 contains alphanumeric", Character.isLetterOrDigit(r1.charAt(i))); + assertTrue(Character.isLetterOrDigit(r1.charAt(i)), "r1 contains alphanumeric"); } r2 = RandomStringUtils.randomAlphabetic(50); - assertTrue("!r1.equals(r2)", !r1.equals(r2)); + assertTrue(!r1.equals(r2), "!r1.equals(r2)"); r1 = RandomStringUtils.randomGraph(50); - assertEquals("randomGraph(50) length", 50, r1.length()); + assertEquals(50, r1.length(), "randomGraph(50) length"); for(int i = 0; i < r1.length(); i++) { - assertTrue("char between 33 and 126", r1.charAt(i) >= 33 && r1.charAt(i) <= 126); + assertTrue(r1.charAt(i) >= 33 && r1.charAt(i) <= 126, "char between 33 and 126"); } r2 = RandomStringUtils.randomGraph(50); - assertTrue("!r1.equals(r2)", !r1.equals(r2)); + assertTrue(!r1.equals(r2), "!r1.equals(r2)"); r1 = RandomStringUtils.randomNumeric(50); - assertEquals("randomNumeric(50)", 50, r1.length()); + assertEquals(50, r1.length(), "randomNumeric(50)"); for(int i = 0; i < r1.length(); i++) { - assertTrue("r1 contains numeric", Character.isDigit(r1.charAt(i)) && !Character.isLetter(r1.charAt(i))); + assertTrue(Character.isDigit(r1.charAt(i)) && !Character.isLetter(r1.charAt(i)), "r1 contains numeric"); } r2 = RandomStringUtils.randomNumeric(50); - assertTrue("!r1.equals(r2)", !r1.equals(r2)); + assertTrue(!r1.equals(r2), "!r1.equals(r2)"); r1 = RandomStringUtils.randomPrint(50); - assertEquals("randomPrint(50) length", 50, r1.length()); + assertEquals(50, r1.length(), "randomPrint(50) length"); for(int i = 0; i < r1.length(); i++) { - assertTrue("char between 32 and 126", r1.charAt(i) >= 32 && r1.charAt(i) <= 126); + assertTrue(r1.charAt(i) >= 32 && r1.charAt(i) <= 126, "char between 32 and 126"); } r2 = RandomStringUtils.randomPrint(50); - assertTrue("!r1.equals(r2)", !r1.equals(r2)); + assertTrue(!r1.equals(r2), "!r1.equals(r2)"); String set = "abcdefg"; r1 = RandomStringUtils.random(50, set); - assertEquals("random(50, \"abcdefg\")", 50, r1.length()); + assertEquals(50, r1.length(), "random(50, \"abcdefg\")"); for(int i = 0; i < r1.length(); i++) { - assertTrue("random char in set", set.indexOf(r1.charAt(i)) > -1); + assertTrue(set.indexOf(r1.charAt(i)) > -1, "random char in set"); } r2 = RandomStringUtils.random(50, set); - assertTrue("!r1.equals(r2)", !r1.equals(r2)); + assertTrue(!r1.equals(r2), "!r1.equals(r2)"); r1 = RandomStringUtils.random(50, (String) null); - assertEquals("random(50) length", 50, r1.length()); + assertEquals(50, r1.length(), "random(50) length"); r2 = RandomStringUtils.random(50, (String) null); - assertEquals("random(50) length", 50, r2.length()); - assertTrue("!r1.equals(r2)", !r1.equals(r2)); + assertEquals(50, r2.length(), "random(50) length"); + assertTrue(!r1.equals(r2), "!r1.equals(r2)"); set = "stuvwxyz"; r1 = RandomStringUtils.random(50, set.toCharArray()); - assertEquals("random(50, \"stuvwxyz\")", 50, r1.length()); + assertEquals(50, r1.length(), "random(50, \"stuvwxyz\")"); for(int i = 0; i < r1.length(); i++) { - assertTrue("random char in set", set.indexOf(r1.charAt(i)) > -1); + assertTrue(set.indexOf(r1.charAt(i)) > -1, "random char in set"); } r2 = RandomStringUtils.random(50, set); - assertTrue("!r1.equals(r2)", !r1.equals(r2)); + assertTrue(!r1.equals(r2), "!r1.equals(r2)"); r1 = RandomStringUtils.random(50, (char[]) null); - assertEquals("random(50) length", 50, r1.length()); + assertEquals(50, r1.length(), "random(50) length"); r2 = RandomStringUtils.random(50, (char[]) null); - assertEquals("random(50) length", 50, r2.length()); - assertTrue("!r1.equals(r2)", !r1.equals(r2)); + assertEquals(50, r2.length(), "random(50) length"); + assertTrue(!r1.equals(r2), "!r1.equals(r2)"); final long seed = System.currentTimeMillis(); r1 = RandomStringUtils.random(50,0,0,true,true,null,new Random(seed)); r2 = RandomStringUtils.random(50,0,0,true,true,null,new Random(seed)); - assertEquals("r1.equals(r2)", r1, r2); + assertEquals(r1, r2, "r1.equals(r2)"); r1 = RandomStringUtils.random(0); - assertEquals("random(0).equals(\"\")", "", r1); + assertEquals("", r1, "random(0).equals(\"\")"); } @Test @@ -162,8 +162,8 @@ public class RandomStringUtilsTest { fail("Expected IllegalArgumentException"); } catch (final IllegalArgumentException ex) { // distinguish from Random#nextInt message final String msg = ex.getMessage(); - assertTrue("Message (" + msg + ") must contain 'start'", msg.contains("start")); - assertTrue("Message (" + msg + ") must contain 'end'", msg.contains("end")); + assertTrue(msg.contains("start"), "Message (" + msg + ") must contain 'start'"); + assertTrue(msg.contains("end"), "Message (" + msg + ") must contain 'end'"); } } @@ -324,7 +324,7 @@ public class RandomStringUtilsTest { for (int i = 0; i < 1000; i++) { final String s = RandomStringUtils.randomAscii(expectedMinLengthInclusive, expectedMaxLengthExclusive); assertThat("within range", s.length(), allOf(greaterThanOrEqualTo(expectedMinLengthInclusive), lessThanOrEqualTo(expectedMaxLengthExclusive - 1))); - assertTrue(s, s.matches(pattern)); + assertTrue(s.matches(pattern), s); if (s.length() < minCreatedLength) { minCreatedLength = s.length(); @@ -349,7 +349,7 @@ public class RandomStringUtilsTest { for (int i = 0; i < 1000; i++) { final String s = RandomStringUtils.randomAlphabetic(expectedMinLengthInclusive, expectedMaxLengthExclusive); assertThat("within range", s.length(), allOf(greaterThanOrEqualTo(expectedMinLengthInclusive), lessThanOrEqualTo(expectedMaxLengthExclusive - 1))); - assertTrue(s, s.matches(pattern)); + assertTrue(s.matches(pattern), s); if (s.length() < minCreatedLength) { minCreatedLength = s.length(); @@ -374,7 +374,7 @@ public class RandomStringUtilsTest { for (int i = 0; i < 1000; i++) { final String s = RandomStringUtils.randomAlphanumeric(expectedMinLengthInclusive, expectedMaxLengthExclusive); assertThat("within range", s.length(), allOf(greaterThanOrEqualTo(expectedMinLengthInclusive), lessThanOrEqualTo(expectedMaxLengthExclusive - 1))); - assertTrue(s, s.matches(pattern)); + assertTrue(s.matches(pattern), s); if (s.length() < minCreatedLength) { minCreatedLength = s.length(); @@ -399,7 +399,7 @@ public class RandomStringUtilsTest { for (int i = 0; i < 1000; i++) { final String s = RandomStringUtils.randomGraph(expectedMinLengthInclusive, expectedMaxLengthExclusive); assertThat("within range", s.length(), allOf(greaterThanOrEqualTo(expectedMinLengthInclusive), lessThanOrEqualTo(expectedMaxLengthExclusive - 1))); - assertTrue(s, s.matches(pattern)); + assertTrue(s.matches(pattern), s); if (s.length() < minCreatedLength) { minCreatedLength = s.length(); @@ -424,7 +424,7 @@ public class RandomStringUtilsTest { for (int i = 0; i < 1000; i++) { final String s = RandomStringUtils.randomNumeric(expectedMinLengthInclusive, expectedMaxLengthExclusive); assertThat("within range", s.length(), allOf(greaterThanOrEqualTo(expectedMinLengthInclusive), lessThanOrEqualTo(expectedMaxLengthExclusive - 1))); - assertTrue(s, s.matches(pattern)); + assertTrue(s.matches(pattern), s); if (s.length() < minCreatedLength) { minCreatedLength = s.length(); @@ -449,7 +449,7 @@ public class RandomStringUtilsTest { for (int i = 0; i < 1000; i++) { final String s = RandomStringUtils.randomPrint(expectedMinLengthInclusive, expectedMaxLengthExclusive); assertThat("within range", s.length(), allOf(greaterThanOrEqualTo(expectedMinLengthInclusive), lessThanOrEqualTo(expectedMaxLengthExclusive - 1))); - assertTrue(s, s.matches(pattern)); + assertTrue(s.matches(pattern), s); if (s.length() < minCreatedLength) { minCreatedLength = s.length(); @@ -488,8 +488,7 @@ public class RandomStringUtilsTest { } } // Perform chi-square test with df = 3-1 = 2, testing at .001 level - assertTrue("test homogeneity -- will fail about 1 in 1000 times", - chiSquare(expected,counts) < 13.82); + assertTrue(chiSquare(expected,counts) < 13.82, "test homogeneity -- will fail about 1 in 1000 times"); } /** @@ -525,8 +524,9 @@ public class RandomStringUtilsTest { for (int i=0; i < orig.length() && i < copy.length(); i++) { final char o = orig.charAt(i); final char c = copy.charAt(i); - assertEquals("differs at " + i + "(" + Integer.toHexString(new Character(o).hashCode()) + "," + - Integer.toHexString(new Character(c).hashCode()) + ")", o, c); + assertEquals(o, c, + "differs at " + i + "(" + Integer.toHexString(new Character(o).hashCode()) + "," + + Integer.toHexString(new Character(c).hashCode()) + ")"); } // compare length also assertEquals(orig.length(), copy.length()); @@ -559,7 +559,7 @@ public class RandomStringUtilsTest { final String result = RandomStringUtils.random(2, start, end, false, false, null, fixedRandom); final int c = result.codePointAt(0); - assertTrue(String.format("Character '%d' not in range [%d,%d).", c, start, end), c >= start && c < end); + assertTrue(c >= start && c < end, String.format("Character '%d' not in range [%d,%d).", c, start, end)); } } diff --git a/src/test/java/org/apache/commons/lang3/RandomUtilsTest.java b/src/test/java/org/apache/commons/lang3/RandomUtilsTest.java index d3a28c630..beab1ad40 100644 --- a/src/test/java/org/apache/commons/lang3/RandomUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/RandomUtilsTest.java @@ -16,13 +16,14 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.junit.Test; +import org.junit.jupiter.api.Test; import java.lang.reflect.Constructor; import java.lang.reflect.Modifier; @@ -47,49 +48,49 @@ public class RandomUtilsTest { assertFalse(Modifier.isFinal(RandomUtils.class.getModifiers())); } - @Test(expected = IllegalArgumentException.class) - public void testNextBytesNegative() throws Exception { - RandomUtils.nextBytes(-1); + @Test + public void testNextBytesNegative() { + assertThrows(IllegalArgumentException.class, () -> RandomUtils.nextBytes(-1)); } - @Test(expected = IllegalArgumentException.class) - public void testNextIntNegative() throws Exception { - RandomUtils.nextInt(-1, 1); + @Test + public void testNextIntNegative() { + assertThrows(IllegalArgumentException.class, () -> RandomUtils.nextInt(-1, 1)); } - @Test(expected = IllegalArgumentException.class) - public void testNextLongNegative() throws Exception { - RandomUtils.nextLong(-1, 1); + @Test + public void testNextLongNegative() { + assertThrows(IllegalArgumentException.class, () -> RandomUtils.nextLong(-1, 1)); } - @Test(expected = IllegalArgumentException.class) - public void testNextDoubleNegative() throws Exception { - RandomUtils.nextDouble(-1, 1); + @Test + public void testNextDoubleNegative() { + assertThrows(IllegalArgumentException.class, () -> RandomUtils.nextDouble(-1, 1)); } - @Test(expected = IllegalArgumentException.class) - public void testNextFloatNegative() throws Exception { - RandomUtils.nextFloat(-1, 1); + @Test + public void testNextFloatNegative() { + assertThrows(IllegalArgumentException.class, () -> RandomUtils.nextFloat(-1, 1)); } - @Test(expected = IllegalArgumentException.class) - public void testNextIntLowerGreaterUpper() throws Exception { - RandomUtils.nextInt(2, 1); + @Test + public void testNextIntLowerGreaterUpper() { + assertThrows(IllegalArgumentException.class, () -> RandomUtils.nextInt(2, 1)); } - @Test(expected = IllegalArgumentException.class) - public void testNextLongLowerGreaterUpper() throws Exception { - RandomUtils.nextLong(2, 1); + @Test + public void testNextLongLowerGreaterUpper() { + assertThrows(IllegalArgumentException.class, () -> RandomUtils.nextLong(2, 1)); } - @Test(expected = IllegalArgumentException.class) - public void testNextDoubleLowerGreaterUpper() throws Exception { - RandomUtils.nextDouble(2, 1); + @Test + public void testNextDoubleLowerGreaterUpper() { + assertThrows(IllegalArgumentException.class, () -> RandomUtils.nextDouble(2, 1)); } - @Test(expected = IllegalArgumentException.class) - public void testNextFloatLowerGreaterUpper() throws Exception { - RandomUtils.nextFloat(2, 1); + @Test + public void testNextFloatLowerGreaterUpper() { + assertThrows(IllegalArgumentException.class, () -> RandomUtils.nextFloat(2, 1)); } /** diff --git a/src/test/java/org/apache/commons/lang3/RangeTest.java b/src/test/java/org/apache/commons/lang3/RangeTest.java index e41fae944..530cef5d4 100644 --- a/src/test/java/org/apache/commons/lang3/RangeTest.java +++ b/src/test/java/org/apache/commons/lang3/RangeTest.java @@ -17,17 +17,18 @@ package org.apache.commons.lang3; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertSame; +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.util.Comparator; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; /** *

@@ -47,7 +48,7 @@ public class RangeTest { private Range doubleRange; @SuppressWarnings("cast") // intRange - @Before + @BeforeEach public void setUp() { byteRange = Range.between((byte) 0, (byte) 5); byteRange2 = Range.between((byte) 0, (byte) 5); @@ -84,13 +85,13 @@ public class RangeTest { } }; Range ri = Range.is(10); - assertFalse("should not contain null", ri.contains(null)); - assertTrue("should contain 10", ri.contains(10)); - assertFalse("should not contain 11", ri.contains(11)); + assertFalse(ri.contains(null), "should not contain null"); + assertTrue(ri.contains(10), "should contain 10"); + assertFalse(ri.contains(11), "should not contain 11"); ri = Range.is(10, c); - assertFalse("should not contain null", ri.contains(null)); - assertTrue("should contain 10", ri.contains(10)); - assertTrue("should contain 11", ri.contains(11)); + assertFalse(ri.contains(null), "should not contain null"); + assertTrue(ri.contains(10), "should contain 10"); + assertTrue(ri.contains(11), "should contain 11"); } @Test @@ -108,29 +109,29 @@ public class RangeTest { } }; Range rb = Range.between(-10, 20); - assertFalse("should not contain null", rb.contains(null)); - assertTrue("should contain 10", rb.contains(10)); - assertTrue("should contain -10", rb.contains(-10)); - assertFalse("should not contain 21", rb.contains(21)); - assertFalse("should not contain -11", rb.contains(-11)); + assertFalse(rb.contains(null), "should not contain null"); + assertTrue(rb.contains(10), "should contain 10"); + assertTrue(rb.contains(-10), "should contain -10"); + assertFalse(rb.contains(21), "should not contain 21"); + assertFalse(rb.contains(-11), "should not contain -11"); rb = Range.between(-10, 20, c); - assertFalse("should not contain null", rb.contains(null)); - assertTrue("should contain 10", rb.contains(10)); - assertTrue("should contain -10", rb.contains(-10)); - assertTrue("should contain 21", rb.contains(21)); - assertTrue("should contain -11", rb.contains(-11)); + assertFalse(rb.contains(null), "should not contain null"); + assertTrue(rb.contains(10), "should contain 10"); + assertTrue(rb.contains(-10), "should contain -10"); + assertTrue(rb.contains(21), "should contain 21"); + assertTrue(rb.contains(-11), "should contain -11"); Range rbstr = Range.between("house", "i"); - assertFalse("should not contain null", rbstr.contains(null)); - assertTrue("should contain house", rbstr.contains("house")); - assertTrue("should contain i", rbstr.contains("i")); - assertFalse("should not contain hose", rbstr.contains("hose")); - assertFalse("should not contain ice", rbstr.contains("ice")); + assertFalse(rbstr.contains(null), "should not contain null"); + assertTrue(rbstr.contains("house"), "should contain house"); + assertTrue(rbstr.contains("i"), "should contain i"); + assertFalse(rbstr.contains("hose"), "should not contain hose"); + assertFalse(rbstr.contains("ice"), "should not contain ice"); rbstr = Range.between("house", "i", lengthComp); - assertFalse("should not contain null", rbstr.contains(null)); - assertTrue("should contain house", rbstr.contains("house")); - assertTrue("should contain i", rbstr.contains("i")); - assertFalse("should not contain houses", rbstr.contains("houses")); - assertFalse("should not contain ''", rbstr.contains("")); + assertFalse(rbstr.contains(null), "should not contain null"); + assertTrue(rbstr.contains("house"), "should contain house"); + assertTrue(rbstr.contains("i"), "should contain i"); + assertFalse(rbstr.contains("houses"), "should not contain houses"); + assertFalse(rbstr.contains(""), "should not contain ''"); } // ----------------------------------------------------------------------- @@ -375,14 +376,14 @@ public class RangeTest { assertEquals(Range.between(10, 15), intRange.intersectionWith(Range.between(5, 15))); } - @Test(expected = IllegalArgumentException.class) + @Test public void testIntersectionWithNull() { - intRange.intersectionWith(null); + assertThrows(IllegalArgumentException.class, () -> intRange.intersectionWith(null)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testIntersectionWithNonOverlapping() { - intRange.intersectionWith(Range.between(0, 9)); + assertThrows(IllegalArgumentException.class, () -> intRange.intersectionWith(Range.between(0, 9))); } // ----------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/lang3/RegExUtilsTest.java b/src/test/java/org/apache/commons/lang3/RegExUtilsTest.java index d3410ff4b..b7bce1fa6 100644 --- a/src/test/java/org/apache/commons/lang3/RegExUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/RegExUtilsTest.java @@ -16,14 +16,14 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.fail; import java.util.regex.Pattern; import java.util.regex.PatternSyntaxException; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Unit tests for methods of {@link org.apache.commons.lang3.RegExUtils} which been moved to their own test classes. diff --git a/src/test/java/org/apache/commons/lang3/SerializationUtilsTest.java b/src/test/java/org/apache/commons/lang3/SerializationUtilsTest.java index 000151d73..e45e33806 100644 --- a/src/test/java/org/apache/commons/lang3/SerializationUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/SerializationUtilsTest.java @@ -16,14 +16,15 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNotSame; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; @@ -37,8 +38,8 @@ import java.lang.reflect.Constructor; import java.lang.reflect.Modifier; import java.util.HashMap; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; /** * Unit tests {@link org.apache.commons.lang3.SerializationUtils}. @@ -52,7 +53,7 @@ public class SerializationUtilsTest { private Integer iInteger; private HashMap iMap; - @Before + @BeforeEach public void setUp() { iString = "foo"; iInteger = Integer.valueOf(7); @@ -114,11 +115,11 @@ public class SerializationUtilsTest { assertArrayEquals(realBytes, testBytes); } - @Test(expected = SerializationException.class) - public void testSerializeStreamUnserializable() throws Exception { + @Test + public void testSerializeStreamUnserializable() { final ByteArrayOutputStream streamTest = new ByteArrayOutputStream(); iMap.put(new Object(), new Object()); - SerializationUtils.serialize(iMap, streamTest); + assertThrows(SerializationException.class, () -> SerializationUtils.serialize(iMap, streamTest)); } @Test @@ -138,14 +139,14 @@ public class SerializationUtilsTest { assertArrayEquals(realBytes, testBytes); } - @Test(expected = IllegalArgumentException.class) - public void testSerializeStreamObjNull() throws Exception { - SerializationUtils.serialize(iMap, null); + @Test + public void testSerializeStreamObjNull() { + assertThrows(IllegalArgumentException.class, () -> SerializationUtils.serialize(iMap, null)); } - @Test(expected = IllegalArgumentException.class) - public void testSerializeStreamNullNull() throws Exception { - SerializationUtils.serialize(null, null); + @Test + public void testSerializeStreamNullNull() { + assertThrows(IllegalArgumentException.class, () -> SerializationUtils.serialize(null, null)); } @Test @@ -188,14 +189,16 @@ public class SerializationUtilsTest { assertEquals(iMap, testMap); } - @Test(expected=ClassCastException.class) + @Test public void testDeserializeClassCastException() { final String value = "Hello"; final byte[] serialized = SerializationUtils.serialize(value); assertEquals(value, SerializationUtils.deserialize(serialized)); - // Causes ClassCastException in call site, not in SerializationUtils.deserialize - @SuppressWarnings("unused") // needed to cause Exception - final Integer i = SerializationUtils.deserialize(serialized); + assertThrows(ClassCastException.class, () -> { + // Causes ClassCastException in call site, not in SerializationUtils.deserialize + @SuppressWarnings("unused") // needed to cause Exception + final Integer i = SerializationUtils.deserialize(serialized); + }); } @Test @@ -211,14 +214,15 @@ public class SerializationUtilsTest { assertNull(test); } - @Test(expected = IllegalArgumentException.class) - public void testDeserializeStreamNull() throws Exception { - SerializationUtils.deserialize((InputStream) null); + @Test + public void testDeserializeStreamNull() { + assertThrows(IllegalArgumentException.class, () -> SerializationUtils.deserialize((InputStream) null)); } - @Test(expected = SerializationException.class) - public void testDeserializeStreamBadStream() throws Exception { - SerializationUtils.deserialize(new ByteArrayInputStream(new byte[0])); + @Test + public void testDeserializeStreamBadStream() { + assertThrows(SerializationException.class, + () -> SerializationUtils.deserialize(new ByteArrayInputStream(new byte[0]))); } @Test @@ -262,10 +266,10 @@ public class SerializationUtilsTest { assertArrayEquals(realBytes, testBytes); } - @Test(expected = SerializationException.class) - public void testSerializeBytesUnserializable() throws Exception { + @Test + public void testSerializeBytesUnserializable() { iMap.put(new Object(), new Object()); - SerializationUtils.serialize(iMap); + assertThrows(SerializationException.class, () -> SerializationUtils.serialize(iMap)); } @Test @@ -317,14 +321,14 @@ public class SerializationUtilsTest { assertNull(test); } - @Test(expected = IllegalArgumentException.class) - public void testDeserializeBytesNull() throws Exception { - SerializationUtils.deserialize((byte[]) null); + @Test + public void testDeserializeBytesNull() { + assertThrows(IllegalArgumentException.class, () -> SerializationUtils.deserialize((byte[]) null)); } - @Test(expected = SerializationException.class) - public void testDeserializeBytesBadStream() throws Exception { - SerializationUtils.deserialize(new byte[0]); + @Test + public void testDeserializeBytesBadStream() { + assertThrows(SerializationException.class, () -> SerializationUtils.deserialize(new byte[0])); } //----------------------------------------------------------------------- @@ -349,10 +353,10 @@ public class SerializationUtilsTest { assertNull(test); } - @Test(expected = SerializationException.class) - public void testCloneUnserializable() throws Exception { + @Test + public void testCloneUnserializable() { iMap.put(new Object(), new Object()); - SerializationUtils.clone(iMap); + assertThrows(SerializationException.class, () -> SerializationUtils.clone(iMap)); } @Test diff --git a/src/test/java/org/apache/commons/lang3/StringEscapeUtilsTest.java b/src/test/java/org/apache/commons/lang3/StringEscapeUtilsTest.java index 178e11d8a..2ff48d31d 100644 --- a/src/test/java/org/apache/commons/lang3/StringEscapeUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/StringEscapeUtilsTest.java @@ -16,12 +16,13 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +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.IOException; import java.io.StringWriter; @@ -34,7 +35,7 @@ import java.nio.file.Paths; import org.apache.commons.lang3.text.translate.CharSequenceTranslator; import org.apache.commons.lang3.text.translate.NumericEntityEscaper; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Unit tests for {@link StringEscapeUtils}. @@ -115,7 +116,7 @@ public class StringEscapeUtilsTest { private void assertEscapeJava(String message, final String expected, final String original) throws IOException { final String converted = StringEscapeUtils.escapeJava(original); message = "escapeJava(String) failed" + (message == null ? "" : (": " + message)); - assertEquals(message, expected, converted); + assertEquals(expected, converted, message); final StringWriter writer = new StringWriter(); StringEscapeUtils.ESCAPE_JAVA.translate(original, writer); @@ -165,12 +166,12 @@ public class StringEscapeUtilsTest { final String expected = unescaped; final String actual = StringEscapeUtils.unescapeJava(original); - assertEquals("unescape(String) failed" + + assertEquals(expected, actual, + "unescape(String) failed" + (message == null ? "" : (": " + message)) + ": expected '" + StringEscapeUtils.escapeJava(expected) + // we escape this so we can see it in the error message - "' actual '" + StringEscapeUtils.escapeJava(actual) + "'", - expected, actual); + "' actual '" + StringEscapeUtils.escapeJava(actual) + "'"); final StringWriter writer = new StringWriter(); StringEscapeUtils.UNESCAPE_JAVA.translate(original, writer); @@ -248,14 +249,14 @@ public class StringEscapeUtilsTest { final String message = element[0]; final String expected = element[1]; final String original = element[2]; - assertEquals(message, expected, StringEscapeUtils.escapeHtml4(original)); + assertEquals(expected, StringEscapeUtils.escapeHtml4(original), message); final StringWriter sw = new StringWriter(); try { StringEscapeUtils.ESCAPE_HTML4.translate(original, sw); } catch (final IOException e) { } final String actual = original == null ? null : sw.toString(); - assertEquals(message, expected, actual); + assertEquals(expected, actual, message); } } @@ -265,7 +266,7 @@ public class StringEscapeUtilsTest { final String message = element[0]; final String expected = element[2]; final String original = element[1]; - assertEquals(message, expected, StringEscapeUtils.unescapeHtml4(original)); + assertEquals(expected, StringEscapeUtils.unescapeHtml4(original), message); final StringWriter sw = new StringWriter(); try { @@ -273,12 +274,12 @@ public class StringEscapeUtilsTest { } catch (final IOException e) { } final String actual = original == null ? null : sw.toString(); - assertEquals(message, expected, actual); + assertEquals(expected, actual, message); } // \u00E7 is a cedilla (c with wiggle under) // note that the test string must be 7-bit-clean (Unicode escaped) or else it will compile incorrectly // on some locales - assertEquals("funny chars pass through OK", "Fran\u00E7ais", StringEscapeUtils.unescapeHtml4("Fran\u00E7ais")); + assertEquals("Fran\u00E7ais", StringEscapeUtils.unescapeHtml4("Fran\u00E7ais"), "funny chars pass through OK"); assertEquals("Hello&;World", StringEscapeUtils.unescapeHtml4("Hello&;World")); assertEquals("Hello&#;World", StringEscapeUtils.unescapeHtml4("Hello&#;World")); @@ -289,8 +290,8 @@ public class StringEscapeUtilsTest { @Test public void testUnescapeHexCharsHtml() { // Simple easy to grok test - assertEquals("hex number unescape", "\u0080\u009F", StringEscapeUtils.unescapeHtml4("€Ÿ")); - assertEquals("hex number unescape", "\u0080\u009F", StringEscapeUtils.unescapeHtml4("€Ÿ")); + assertEquals("\u0080\u009F", StringEscapeUtils.unescapeHtml4("€Ÿ"), "hex number unescape"); + assertEquals("\u0080\u009F", StringEscapeUtils.unescapeHtml4("€Ÿ"), "hex number unescape"); // Test all Character values: for (char i = Character.MIN_VALUE; i < Character.MAX_VALUE; i++) { final Character c1 = new Character(i); @@ -298,7 +299,7 @@ public class StringEscapeUtilsTest { final String expected = c1.toString() + c2.toString(); final String escapedC1 = "&#x" + Integer.toHexString((c1.charValue())) + ";"; final String escapedC2 = "&#x" + Integer.toHexString((c2.charValue())) + ";"; - assertEquals("hex number unescape index " + (int)i, expected, StringEscapeUtils.unescapeHtml4(escapedC1 + escapedC2)); + assertEquals(expected, StringEscapeUtils.unescapeHtml4(escapedC1 + escapedC2), "hex number unescape index " + (int)i); } } @@ -320,16 +321,14 @@ public class StringEscapeUtilsTest { assertEquals("<abc>", StringEscapeUtils.escapeXml("")); assertEquals("", StringEscapeUtils.unescapeXml("<abc>")); - assertEquals("XML should not escape >0x7f values", - "\u00A1", StringEscapeUtils.escapeXml("\u00A1")); - assertEquals("XML should be able to unescape >0x7f values", - "\u00A0", StringEscapeUtils.unescapeXml(" ")); - assertEquals("XML should be able to unescape >0x7f values with one leading 0", - "\u00A0", StringEscapeUtils.unescapeXml(" ")); - assertEquals("XML should be able to unescape >0x7f values with two leading 0s", - "\u00A0", StringEscapeUtils.unescapeXml(" ")); - assertEquals("XML should be able to unescape >0x7f values with three leading 0s", - "\u00A0", StringEscapeUtils.unescapeXml(" ")); + assertEquals("\u00A1", StringEscapeUtils.escapeXml("\u00A1"), "XML should not escape >0x7f values"); + assertEquals("\u00A0", StringEscapeUtils.unescapeXml(" "), "XML should be able to unescape >0x7f values"); + assertEquals("\u00A0", StringEscapeUtils.unescapeXml(" "), + "XML should be able to unescape >0x7f values with one leading 0"); + assertEquals("\u00A0", StringEscapeUtils.unescapeXml(" "), + "XML should be able to unescape >0x7f values with two leading 0s"); + assertEquals("\u00A0", StringEscapeUtils.unescapeXml(" "), + "XML should be able to unescape >0x7f values with three leading 0s"); assertEquals("ain't", StringEscapeUtils.unescapeXml("ain't")); assertEquals("ain't", StringEscapeUtils.escapeXml("ain't")); @@ -342,46 +341,46 @@ public class StringEscapeUtilsTest { StringEscapeUtils.ESCAPE_XML.translate("", sw); } catch (final IOException e) { } - assertEquals("XML was escaped incorrectly", "<abc>", sw.toString() ); + assertEquals("<abc>", sw.toString(), "XML was escaped incorrectly"); sw = new StringWriter(); try { StringEscapeUtils.UNESCAPE_XML.translate("<abc>", sw); } catch (final IOException e) { } - assertEquals("XML was unescaped incorrectly", "", sw.toString() ); + assertEquals("", sw.toString(), "XML was unescaped incorrectly"); } @Test public void testEscapeXml10() throws Exception { assertEquals("a<b>c"d'e&f", StringEscapeUtils.escapeXml10("ac\"d'e&f")); - assertEquals("XML 1.0 should not escape \t \n \r", - "a\tb\rc\nd", StringEscapeUtils.escapeXml10("a\tb\rc\nd")); - assertEquals("XML 1.0 should omit most #x0-x8 | #xb | #xc | #xe-#x19", - "ab", StringEscapeUtils.escapeXml10("a\u0000\u0001\u0008\u000b\u000c\u000e\u001fb")); - assertEquals("XML 1.0 should omit #xd800-#xdfff", - "a\ud7ff \ue000b", StringEscapeUtils.escapeXml10("a\ud7ff\ud800 \udfff \ue000b")); - assertEquals("XML 1.0 should omit #xfffe | #xffff", - "a\ufffdb", StringEscapeUtils.escapeXml10("a\ufffd\ufffe\uffffb")); - assertEquals("XML 1.0 should escape #x7f-#x84 | #x86 - #x9f, for XML 1.1 compatibility", - "a\u007e„\u0085†Ÿ\u00a0b", StringEscapeUtils.escapeXml10("a\u007e\u007f\u0084\u0085\u0086\u009f\u00a0b")); + assertEquals("a\tb\rc\nd", StringEscapeUtils.escapeXml10("a\tb\rc\nd"), "XML 1.0 should not escape \t \n \r"); + assertEquals("ab", StringEscapeUtils.escapeXml10("a\u0000\u0001\u0008\u000b\u000c\u000e\u001fb"), + "XML 1.0 should omit most #x0-x8 | #xb | #xc | #xe-#x19"); + assertEquals("a\ud7ff \ue000b", StringEscapeUtils.escapeXml10("a\ud7ff\ud800 \udfff \ue000b"), + "XML 1.0 should omit #xd800-#xdfff"); + assertEquals("a\ufffdb", StringEscapeUtils.escapeXml10("a\ufffd\ufffe\uffffb"), + "XML 1.0 should omit #xfffe | #xffff"); + assertEquals("a\u007e„\u0085†Ÿ\u00a0b", + StringEscapeUtils.escapeXml10("a\u007e\u007f\u0084\u0085\u0086\u009f\u00a0b"), + "XML 1.0 should escape #x7f-#x84 | #x86 - #x9f, for XML 1.1 compatibility"); } @Test public void testEscapeXml11() throws Exception { assertEquals("a<b>c"d'e&f", StringEscapeUtils.escapeXml11("ac\"d'e&f")); - assertEquals("XML 1.1 should not escape \t \n \r", - "a\tb\rc\nd", StringEscapeUtils.escapeXml11("a\tb\rc\nd")); - assertEquals("XML 1.1 should omit #x0", - "ab", StringEscapeUtils.escapeXml11("a\u0000b")); - assertEquals("XML 1.1 should escape #x1-x8 | #xb | #xc | #xe-#x19", - "a b", StringEscapeUtils.escapeXml11("a\u0001\u0008\u000b\u000c\u000e\u001fb")); - assertEquals("XML 1.1 should escape #x7F-#x84 | #x86-#x9F", - "a\u007e„\u0085†Ÿ\u00a0b", StringEscapeUtils.escapeXml11("a\u007e\u007f\u0084\u0085\u0086\u009f\u00a0b")); - assertEquals("XML 1.1 should omit #xd800-#xdfff", - "a\ud7ff \ue000b", StringEscapeUtils.escapeXml11("a\ud7ff\ud800 \udfff \ue000b")); - assertEquals("XML 1.1 should omit #xfffe | #xffff", - "a\ufffdb", StringEscapeUtils.escapeXml11("a\ufffd\ufffe\uffffb")); + assertEquals("a\tb\rc\nd", StringEscapeUtils.escapeXml11("a\tb\rc\nd"), "XML 1.1 should not escape \t \n \r"); + assertEquals("ab", StringEscapeUtils.escapeXml11("a\u0000b"), "XML 1.1 should omit #x0"); + assertEquals("a b", + StringEscapeUtils.escapeXml11("a\u0001\u0008\u000b\u000c\u000e\u001fb"), + "XML 1.1 should escape #x1-x8 | #xb | #xc | #xe-#x19"); + assertEquals("a\u007e„\u0085†Ÿ\u00a0b", + StringEscapeUtils.escapeXml11("a\u007e\u007f\u0084\u0085\u0086\u009f\u00a0b"), + "XML 1.1 should escape #x7F-#x84 | #x86-#x9F"); + assertEquals("a\ud7ff \ue000b", StringEscapeUtils.escapeXml11("a\ud7ff\ud800 \udfff \ue000b"), + "XML 1.1 should omit #xd800-#xdfff"); + assertEquals("a\ufffdb", StringEscapeUtils.escapeXml11("a\ufffd\ufffe\uffffb"), + "XML 1.1 should omit #xfffe | #xffff"); } /** @@ -404,11 +403,11 @@ public class StringEscapeUtilsTest { final CharSequenceTranslator escapeXml = StringEscapeUtils.ESCAPE_XML.with( NumericEntityEscaper.between(0x7f, Integer.MAX_VALUE) ); - assertEquals("Supplementary character must be represented using a single escape", "𣎴", - escapeXml.translate("\uD84C\uDFB4")); + assertEquals("𣎴", escapeXml.translate("\uD84C\uDFB4"), + "Supplementary character must be represented using a single escape"); - assertEquals("Supplementary characters mixed with basic characters should be encoded correctly", "a b c 𣎴", - escapeXml.translate("a b c \uD84C\uDFB4")); + assertEquals("a b c 𣎴", escapeXml.translate("a b c \uD84C\uDFB4"), + "Supplementary characters mixed with basic characters should be encoded correctly"); } @Test @@ -436,11 +435,11 @@ public class StringEscapeUtilsTest { */ @Test public void testUnescapeXmlSupplementaryCharacters() { - assertEquals("Supplementary character must be represented using a single escape", "\uD84C\uDFB4", - StringEscapeUtils.unescapeXml("𣎴") ); + assertEquals("\uD84C\uDFB4", StringEscapeUtils.unescapeXml("𣎴"), + "Supplementary character must be represented using a single escape"); - assertEquals("Supplementary characters mixed with basic characters should be decoded correctly", "a b c \uD84C\uDFB4", - StringEscapeUtils.unescapeXml("a b c 𣎴") ); + assertEquals("a b c \uD84C\uDFB4", StringEscapeUtils.unescapeXml("a b c 𣎴"), + "Supplementary characters mixed with basic characters should be decoded correctly"); } // Tests issue #38569 @@ -492,10 +491,10 @@ public class StringEscapeUtilsTest { } } - @Test(expected = IllegalStateException.class) - public void testEscapeCsvIllegalStateException() throws IOException { + @Test + public void testEscapeCsvIllegalStateException() { final StringWriter writer = new StringWriter(); - StringEscapeUtils.ESCAPE_CSV.translate("foo", -1, writer); + assertThrows(IllegalStateException.class, () -> StringEscapeUtils.ESCAPE_CSV.translate("foo", -1, writer)); } @Test @@ -536,10 +535,10 @@ public class StringEscapeUtilsTest { } } - @Test(expected = IllegalStateException.class) - public void testUnescapeCsvIllegalStateException() throws IOException { + @Test + public void testUnescapeCsvIllegalStateException() { final StringWriter writer = new StringWriter(); - StringEscapeUtils.UNESCAPE_CSV.translate("foo", -1, writer); + assertThrows(IllegalStateException.class, () -> StringEscapeUtils.UNESCAPE_CSV.translate("foo", -1, writer)); } /** @@ -556,10 +555,10 @@ public class StringEscapeUtilsTest { final String original = new String(data, Charset.forName("UTF8")); final String escaped = StringEscapeUtils.escapeHtml4( original ); - assertEquals( "High Unicode should not have been escaped", original, escaped); + assertEquals(original, escaped, "High Unicode should not have been escaped"); final String unescaped = StringEscapeUtils.unescapeHtml4( escaped ); - assertEquals( "High Unicode should have been unchanged", original, unescaped); + assertEquals(original, unescaped, "High Unicode should have been unchanged"); // TODO: I think this should hold, needs further investigation // String unescapedFromEntity = StringEscapeUtils.unescapeHtml4( "𝍢" ); @@ -574,12 +573,12 @@ public class StringEscapeUtilsTest { // Some random Japanese Unicode characters final String original = "\u304B\u304C\u3068"; final String escaped = StringEscapeUtils.escapeHtml4(original); - assertEquals( "Hiragana character Unicode behaviour should not be being escaped by escapeHtml4", - original, escaped); + assertEquals(original, escaped, + "Hiragana character Unicode behaviour should not be being escaped by escapeHtml4"); final String unescaped = StringEscapeUtils.unescapeHtml4( escaped ); - assertEquals( "Hiragana character Unicode behaviour has changed - expected no unescaping", escaped, unescaped); + assertEquals(escaped, unescaped, "Hiragana character Unicode behaviour has changed - expected no unescaping"); } /** @@ -594,9 +593,9 @@ public class StringEscapeUtilsTest { final String input = new String(inputBytes, StandardCharsets.UTF_8); final String escaped = StringEscapeUtils.escapeEcmaScript(input); // just the end: - assertTrue(escaped, escaped.endsWith("}]")); + assertTrue(escaped.endsWith("}]"), escaped); // a little more: - assertTrue(escaped, escaped.endsWith("\"valueCode\\\":\\\"\\\"}]")); + assertTrue(escaped.endsWith("\"valueCode\\\":\\\"\\\"}]"), escaped); } /** diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsContainsTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsContainsTest.java index 5cc635fe9..b543bf799 100644 --- a/src/test/java/org/apache/commons/lang3/StringUtilsContainsTest.java +++ b/src/test/java/org/apache/commons/lang3/StringUtilsContainsTest.java @@ -16,25 +16,19 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.Locale; -import org.apache.commons.lang3.test.SystemDefaultsSwitch; -import org.apache.commons.lang3.test.SystemDefaults; -import org.junit.Rule; -import org.junit.Test; +import org.junit.jupiter.api.Test; +import org.junitpioneer.jupiter.DefaultLocale; /** * Unit tests {@link org.apache.commons.lang3.StringUtils} - Contains methods */ public class StringUtilsContainsTest { - - @Rule - public SystemDefaultsSwitch defaults = new SystemDefaultsSwitch(); - /** * Supplementary character U+20000 * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html @@ -233,7 +227,7 @@ public class StringUtilsContainsTest { assertTrue(StringUtils.containsAny("abc", "d", "abc")); } - @SystemDefaults(locale="de_DE") + @DefaultLocale(language = "de", country = "DE") @Test public void testContainsIgnoreCase_LocaleIndependence() { final Locale[] locales = { Locale.ENGLISH, new Locale("tr"), Locale.getDefault() }; @@ -253,12 +247,12 @@ public class StringUtilsContainsTest { for (final Locale testLocale : locales) { Locale.setDefault(testLocale); for (int j = 0; j < tdata.length; j++) { - assertTrue(Locale.getDefault() + ": " + j + " " + tdata[j][0] + " " + tdata[j][1], StringUtils - .containsIgnoreCase(tdata[j][0], tdata[j][1])); + assertTrue(StringUtils.containsIgnoreCase(tdata[j][0], tdata[j][1]), + Locale.getDefault() + ": " + j + " " + tdata[j][0] + " " + tdata[j][1]); } for (int j = 0; j < fdata.length; j++) { - assertFalse(Locale.getDefault() + ": " + j + " " + fdata[j][0] + " " + fdata[j][1], StringUtils - .containsIgnoreCase(fdata[j][0], fdata[j][1])); + assertFalse(StringUtils.containsIgnoreCase(fdata[j][0], fdata[j][1]), + Locale.getDefault() + ": " + j + " " + fdata[j][0] + " " + fdata[j][1]); } } } diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsEmptyBlankTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsEmptyBlankTest.java index 2eb73680d..12e050517 100644 --- a/src/test/java/org/apache/commons/lang3/StringUtilsEmptyBlankTest.java +++ b/src/test/java/org/apache/commons/lang3/StringUtilsEmptyBlankTest.java @@ -16,12 +16,12 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; +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 org.junit.Test; +import org.junit.jupiter.api.Test; /** * Unit tests {@link org.apache.commons.lang3.StringUtils} - Empty/Blank methods diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java index f992ef7f3..c9a9fd15e 100644 --- a/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java +++ b/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java @@ -16,26 +16,20 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertThat; -import static org.junit.Assert.assertTrue; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.Locale; -import org.apache.commons.lang3.test.SystemDefaultsSwitch; import org.hamcrest.core.IsNot; -import org.junit.Rule; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Unit tests {@link org.apache.commons.lang3.StringUtils} - Equals/IndexOf methods */ public class StringUtilsEqualsIndexOfTest { - - @Rule - public SystemDefaultsSwitch defaults = new SystemDefaultsSwitch(); - private static final String BAR = "bar"; /** * Supplementary character U+20000 diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsIsTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsIsTest.java index 4160f1a5d..ad3e2da07 100644 --- a/src/test/java/org/apache/commons/lang3/StringUtilsIsTest.java +++ b/src/test/java/org/apache/commons/lang3/StringUtilsIsTest.java @@ -16,10 +16,10 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Unit tests {@link org.apache.commons.lang3.StringUtils} - IsX methods diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsStartsEndsWithTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsStartsEndsWithTest.java index 2eb5ddb58..5f815c635 100644 --- a/src/test/java/org/apache/commons/lang3/StringUtilsStartsEndsWithTest.java +++ b/src/test/java/org/apache/commons/lang3/StringUtilsStartsEndsWithTest.java @@ -16,10 +16,10 @@ */ package org.apache.commons.lang3; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; /** @@ -40,23 +40,23 @@ public class StringUtilsStartsEndsWithTest { */ @Test public void testStartsWith() { - assertTrue("startsWith(null, null)", StringUtils.startsWith(null, null)); - assertFalse("startsWith(FOOBAR, null)", StringUtils.startsWith(FOOBAR, null)); - assertFalse("startsWith(null, FOO)", StringUtils.startsWith(null, FOO)); - assertTrue("startsWith(FOOBAR, \"\")", StringUtils.startsWith(FOOBAR, "")); + assertTrue(StringUtils.startsWith(null, null), "startsWith(null, null)"); + assertFalse(StringUtils.startsWith(FOOBAR, null), "startsWith(FOOBAR, null)"); + assertFalse(StringUtils.startsWith(null, FOO), "startsWith(null, FOO)"); + assertTrue(StringUtils.startsWith(FOOBAR, ""), "startsWith(FOOBAR, \"\")"); - assertTrue("startsWith(foobar, foo)", StringUtils.startsWith(foobar, foo)); - assertTrue("startsWith(FOOBAR, FOO)", StringUtils.startsWith(FOOBAR, FOO)); - assertFalse("startsWith(foobar, FOO)", StringUtils.startsWith(foobar, FOO)); - assertFalse("startsWith(FOOBAR, foo)", StringUtils.startsWith(FOOBAR, foo)); + assertTrue(StringUtils.startsWith(foobar, foo), "startsWith(foobar, foo)"); + assertTrue(StringUtils.startsWith(FOOBAR, FOO), "startsWith(FOOBAR, FOO)"); + assertFalse(StringUtils.startsWith(foobar, FOO), "startsWith(foobar, FOO)"); + assertFalse(StringUtils.startsWith(FOOBAR, foo), "startsWith(FOOBAR, foo)"); - assertFalse("startsWith(foo, foobar)", StringUtils.startsWith(foo, foobar)); - assertFalse("startsWith(foo, foobar)", StringUtils.startsWith(bar, foobar)); + assertFalse(StringUtils.startsWith(foo, foobar), "startsWith(foo, foobar)"); + assertFalse(StringUtils.startsWith(bar, foobar), "startsWith(foo, foobar)"); - assertFalse("startsWith(foobar, bar)", StringUtils.startsWith(foobar, bar)); - assertFalse("startsWith(FOOBAR, BAR)", StringUtils.startsWith(FOOBAR, BAR)); - assertFalse("startsWith(foobar, BAR)", StringUtils.startsWith(foobar, BAR)); - assertFalse("startsWith(FOOBAR, bar)", StringUtils.startsWith(FOOBAR, bar)); + assertFalse(StringUtils.startsWith(foobar, bar), "startsWith(foobar, bar)"); + assertFalse(StringUtils.startsWith(FOOBAR, BAR), "startsWith(FOOBAR, BAR)"); + assertFalse(StringUtils.startsWith(foobar, BAR), "startsWith(foobar, BAR)"); + assertFalse(StringUtils.startsWith(FOOBAR, bar), "startsWith(FOOBAR, bar)"); } /** @@ -64,23 +64,23 @@ public class StringUtilsStartsEndsWithTest { */ @Test public void testStartsWithIgnoreCase() { - assertTrue("startsWithIgnoreCase(null, null)", StringUtils.startsWithIgnoreCase(null, null)); - assertFalse("startsWithIgnoreCase(FOOBAR, null)", StringUtils.startsWithIgnoreCase(FOOBAR, null)); - assertFalse("startsWithIgnoreCase(null, FOO)", StringUtils.startsWithIgnoreCase(null, FOO)); - assertTrue("startsWithIgnoreCase(FOOBAR, \"\")", StringUtils.startsWithIgnoreCase(FOOBAR, "")); + assertTrue(StringUtils.startsWithIgnoreCase(null, null), "startsWithIgnoreCase(null, null)"); + assertFalse(StringUtils.startsWithIgnoreCase(FOOBAR, null), "startsWithIgnoreCase(FOOBAR, null)"); + assertFalse(StringUtils.startsWithIgnoreCase(null, FOO), "startsWithIgnoreCase(null, FOO)"); + assertTrue(StringUtils.startsWithIgnoreCase(FOOBAR, ""), "startsWithIgnoreCase(FOOBAR, \"\")"); - assertTrue("startsWithIgnoreCase(foobar, foo)", StringUtils.startsWithIgnoreCase(foobar, foo)); - assertTrue("startsWithIgnoreCase(FOOBAR, FOO)", StringUtils.startsWithIgnoreCase(FOOBAR, FOO)); - assertTrue("startsWithIgnoreCase(foobar, FOO)", StringUtils.startsWithIgnoreCase(foobar, FOO)); - assertTrue("startsWithIgnoreCase(FOOBAR, foo)", StringUtils.startsWithIgnoreCase(FOOBAR, foo)); + assertTrue(StringUtils.startsWithIgnoreCase(foobar, foo), "startsWithIgnoreCase(foobar, foo)"); + assertTrue(StringUtils.startsWithIgnoreCase(FOOBAR, FOO), "startsWithIgnoreCase(FOOBAR, FOO)"); + assertTrue(StringUtils.startsWithIgnoreCase(foobar, FOO), "startsWithIgnoreCase(foobar, FOO)"); + assertTrue(StringUtils.startsWithIgnoreCase(FOOBAR, foo), "startsWithIgnoreCase(FOOBAR, foo)"); - assertFalse("startsWithIgnoreCase(foo, foobar)", StringUtils.startsWithIgnoreCase(foo, foobar)); - assertFalse("startsWithIgnoreCase(foo, foobar)", StringUtils.startsWithIgnoreCase(bar, foobar)); + assertFalse(StringUtils.startsWithIgnoreCase(foo, foobar), "startsWithIgnoreCase(foo, foobar)"); + assertFalse(StringUtils.startsWithIgnoreCase(bar, foobar), "startsWithIgnoreCase(foo, foobar)"); - assertFalse("startsWithIgnoreCase(foobar, bar)", StringUtils.startsWithIgnoreCase(foobar, bar)); - assertFalse("startsWithIgnoreCase(FOOBAR, BAR)", StringUtils.startsWithIgnoreCase(FOOBAR, BAR)); - assertFalse("startsWithIgnoreCase(foobar, BAR)", StringUtils.startsWithIgnoreCase(foobar, BAR)); - assertFalse("startsWithIgnoreCase(FOOBAR, bar)", StringUtils.startsWithIgnoreCase(FOOBAR, bar)); + assertFalse(StringUtils.startsWithIgnoreCase(foobar, bar), "startsWithIgnoreCase(foobar, bar)"); + assertFalse(StringUtils.startsWithIgnoreCase(FOOBAR, BAR), "startsWithIgnoreCase(FOOBAR, BAR)"); + assertFalse(StringUtils.startsWithIgnoreCase(foobar, BAR), "startsWithIgnoreCase(foobar, BAR)"); + assertFalse(StringUtils.startsWithIgnoreCase(FOOBAR, bar), "startsWithIgnoreCase(FOOBAR, bar)"); } @Test @@ -96,8 +96,8 @@ public class StringUtilsStartsEndsWithTest { assertFalse(StringUtils.startsWithAny("abcxyz", null, "xyz", "ABCX")); assertFalse(StringUtils.startsWithAny("ABCXYZ", null, "xyz", "abc")); - assertTrue("StringUtils.startsWithAny(abcxyz, StringBuilder(xyz), StringBuffer(abc))", StringUtils.startsWithAny("abcxyz", new StringBuilder("xyz"), new StringBuffer("abc"))); - assertTrue("StringUtils.startsWithAny(StringBuffer(abcxyz), StringBuilder(xyz), StringBuffer(abc))", StringUtils.startsWithAny(new StringBuffer("abcxyz"), new StringBuilder("xyz"), new StringBuffer("abc"))); + assertTrue(StringUtils.startsWithAny("abcxyz", new StringBuilder("xyz"), new StringBuffer("abc")), "StringUtils.startsWithAny(abcxyz, StringBuilder(xyz), StringBuffer(abc))"); + assertTrue(StringUtils.startsWithAny(new StringBuffer("abcxyz"), new StringBuilder("xyz"), new StringBuffer("abc")), "StringUtils.startsWithAny(StringBuffer(abcxyz), StringBuilder(xyz), StringBuffer(abc))"); } @@ -106,30 +106,30 @@ public class StringUtilsStartsEndsWithTest { */ @Test public void testEndsWith() { - assertTrue("endsWith(null, null)", StringUtils.endsWith(null, null)); - assertFalse("endsWith(FOOBAR, null)", StringUtils.endsWith(FOOBAR, null)); - assertFalse("endsWith(null, FOO)", StringUtils.endsWith(null, FOO)); - assertTrue("endsWith(FOOBAR, \"\")", StringUtils.endsWith(FOOBAR, "")); + assertTrue(StringUtils.endsWith(null, null), "endsWith(null, null)"); + assertFalse(StringUtils.endsWith(FOOBAR, null), "endsWith(FOOBAR, null)"); + assertFalse(StringUtils.endsWith(null, FOO), "endsWith(null, FOO)"); + assertTrue(StringUtils.endsWith(FOOBAR, ""), "endsWith(FOOBAR, \"\")"); - assertFalse("endsWith(foobar, foo)", StringUtils.endsWith(foobar, foo)); - assertFalse("endsWith(FOOBAR, FOO)", StringUtils.endsWith(FOOBAR, FOO)); - assertFalse("endsWith(foobar, FOO)", StringUtils.endsWith(foobar, FOO)); - assertFalse("endsWith(FOOBAR, foo)", StringUtils.endsWith(FOOBAR, foo)); + assertFalse(StringUtils.endsWith(foobar, foo), "endsWith(foobar, foo)"); + assertFalse(StringUtils.endsWith(FOOBAR, FOO), "endsWith(FOOBAR, FOO)"); + assertFalse(StringUtils.endsWith(foobar, FOO), "endsWith(foobar, FOO)"); + assertFalse(StringUtils.endsWith(FOOBAR, foo), "endsWith(FOOBAR, foo)"); - assertFalse("endsWith(foo, foobar)", StringUtils.endsWith(foo, foobar)); - assertFalse("endsWith(foo, foobar)", StringUtils.endsWith(bar, foobar)); + assertFalse(StringUtils.endsWith(foo, foobar), "endsWith(foo, foobar)"); + assertFalse(StringUtils.endsWith(bar, foobar), "endsWith(foo, foobar)"); - assertTrue("endsWith(foobar, bar)", StringUtils.endsWith(foobar, bar)); - assertTrue("endsWith(FOOBAR, BAR)", StringUtils.endsWith(FOOBAR, BAR)); - assertFalse("endsWith(foobar, BAR)", StringUtils.endsWith(foobar, BAR)); - assertFalse("endsWith(FOOBAR, bar)", StringUtils.endsWith(FOOBAR, bar)); + assertTrue(StringUtils.endsWith(foobar, bar), "endsWith(foobar, bar)"); + assertTrue(StringUtils.endsWith(FOOBAR, BAR), "endsWith(FOOBAR, BAR)"); + assertFalse(StringUtils.endsWith(foobar, BAR), "endsWith(foobar, BAR)"); + assertFalse(StringUtils.endsWith(FOOBAR, bar), "endsWith(FOOBAR, bar)"); // "alpha,beta,gamma,delta".endsWith("delta") - assertTrue("endsWith(\u03B1\u03B2\u03B3\u03B4, \u03B4)", - StringUtils.endsWith("\u03B1\u03B2\u03B3\u03B4", "\u03B4")); + assertTrue(StringUtils.endsWith("\u03B1\u03B2\u03B3\u03B4", "\u03B4"), + "endsWith(\u03B1\u03B2\u03B3\u03B4, \u03B4)"); // "alpha,beta,gamma,delta".endsWith("gamma,DELTA") - assertFalse("endsWith(\u03B1\u03B2\u03B3\u03B4, \u03B3\u0394)", - StringUtils.endsWith("\u03B1\u03B2\u03B3\u03B4", "\u03B3\u0394")); + assertFalse(StringUtils.endsWith("\u03B1\u03B2\u03B3\u03B4", "\u03B3\u0394"), + "endsWith(\u03B1\u03B2\u03B3\u03B4, \u03B3\u0394)"); } /** @@ -137,23 +137,23 @@ public class StringUtilsStartsEndsWithTest { */ @Test public void testEndsWithIgnoreCase() { - assertTrue("endsWithIgnoreCase(null, null)", StringUtils.endsWithIgnoreCase(null, null)); - assertFalse("endsWithIgnoreCase(FOOBAR, null)", StringUtils.endsWithIgnoreCase(FOOBAR, null)); - assertFalse("endsWithIgnoreCase(null, FOO)", StringUtils.endsWithIgnoreCase(null, FOO)); - assertTrue("endsWithIgnoreCase(FOOBAR, \"\")", StringUtils.endsWithIgnoreCase(FOOBAR, "")); + assertTrue(StringUtils.endsWithIgnoreCase(null, null), "endsWithIgnoreCase(null, null)"); + assertFalse(StringUtils.endsWithIgnoreCase(FOOBAR, null), "endsWithIgnoreCase(FOOBAR, null)"); + assertFalse(StringUtils.endsWithIgnoreCase(null, FOO), "endsWithIgnoreCase(null, FOO)"); + assertTrue(StringUtils.endsWithIgnoreCase(FOOBAR, ""), "endsWithIgnoreCase(FOOBAR, \"\")"); - assertFalse("endsWithIgnoreCase(foobar, foo)", StringUtils.endsWithIgnoreCase(foobar, foo)); - assertFalse("endsWithIgnoreCase(FOOBAR, FOO)", StringUtils.endsWithIgnoreCase(FOOBAR, FOO)); - assertFalse("endsWithIgnoreCase(foobar, FOO)", StringUtils.endsWithIgnoreCase(foobar, FOO)); - assertFalse("endsWithIgnoreCase(FOOBAR, foo)", StringUtils.endsWithIgnoreCase(FOOBAR, foo)); + assertFalse(StringUtils.endsWithIgnoreCase(foobar, foo), "endsWithIgnoreCase(foobar, foo)"); + assertFalse(StringUtils.endsWithIgnoreCase(FOOBAR, FOO), "endsWithIgnoreCase(FOOBAR, FOO)"); + assertFalse(StringUtils.endsWithIgnoreCase(foobar, FOO), "endsWithIgnoreCase(foobar, FOO)"); + assertFalse(StringUtils.endsWithIgnoreCase(FOOBAR, foo), "endsWithIgnoreCase(FOOBAR, foo)"); - assertFalse("endsWithIgnoreCase(foo, foobar)", StringUtils.endsWithIgnoreCase(foo, foobar)); - assertFalse("endsWithIgnoreCase(foo, foobar)", StringUtils.endsWithIgnoreCase(bar, foobar)); + assertFalse(StringUtils.endsWithIgnoreCase(foo, foobar), "endsWithIgnoreCase(foo, foobar)"); + assertFalse(StringUtils.endsWithIgnoreCase(bar, foobar), "endsWithIgnoreCase(foo, foobar)"); - assertTrue("endsWithIgnoreCase(foobar, bar)", StringUtils.endsWithIgnoreCase(foobar, bar)); - assertTrue("endsWithIgnoreCase(FOOBAR, BAR)", StringUtils.endsWithIgnoreCase(FOOBAR, BAR)); - assertTrue("endsWithIgnoreCase(foobar, BAR)", StringUtils.endsWithIgnoreCase(foobar, BAR)); - assertTrue("endsWithIgnoreCase(FOOBAR, bar)", StringUtils.endsWithIgnoreCase(FOOBAR, bar)); + assertTrue(StringUtils.endsWithIgnoreCase(foobar, bar), "endsWithIgnoreCase(foobar, bar)"); + assertTrue(StringUtils.endsWithIgnoreCase(FOOBAR, BAR), "endsWithIgnoreCase(FOOBAR, BAR)"); + assertTrue(StringUtils.endsWithIgnoreCase(foobar, BAR), "endsWithIgnoreCase(foobar, BAR)"); + assertTrue(StringUtils.endsWithIgnoreCase(FOOBAR, bar), "endsWithIgnoreCase(FOOBAR, bar)"); // javadoc assertTrue(StringUtils.endsWithIgnoreCase("abcdef", "def")); @@ -161,22 +161,22 @@ public class StringUtilsStartsEndsWithTest { assertFalse(StringUtils.endsWithIgnoreCase("ABCDEF", "cde")); // "alpha,beta,gamma,delta".endsWith("DELTA") - assertTrue("endsWith(\u03B1\u03B2\u03B3\u03B4, \u0394)", - StringUtils.endsWithIgnoreCase("\u03B1\u03B2\u03B3\u03B4", "\u0394")); + assertTrue(StringUtils.endsWithIgnoreCase("\u03B1\u03B2\u03B3\u03B4", "\u0394"), + "endsWith(\u03B1\u03B2\u03B3\u03B4, \u0394)"); // "alpha,beta,gamma,delta".endsWith("GAMMA") - assertFalse("endsWith(\u03B1\u03B2\u03B3\u03B4, \u0393)", - StringUtils.endsWithIgnoreCase("\u03B1\u03B2\u03B3\u03B4", "\u0393")); + assertFalse(StringUtils.endsWithIgnoreCase("\u03B1\u03B2\u03B3\u03B4", "\u0393"), + "endsWith(\u03B1\u03B2\u03B3\u03B4, \u0393)"); } @Test public void testEndsWithAny() { - assertFalse("StringUtils.endsWithAny(null, null)", StringUtils.endsWithAny(null, (String)null)); - assertFalse("StringUtils.endsWithAny(null, new String[] {abc})", StringUtils.endsWithAny(null, new String[] {"abc"})); - assertFalse("StringUtils.endsWithAny(abcxyz, null)", StringUtils.endsWithAny("abcxyz", (String)null)); - assertTrue("StringUtils.endsWithAny(abcxyz, new String[] {\"\"})", StringUtils.endsWithAny("abcxyz", new String[] {""})); - assertTrue("StringUtils.endsWithAny(abcxyz, new String[] {xyz})", StringUtils.endsWithAny("abcxyz", new String[] {"xyz"})); - assertTrue("StringUtils.endsWithAny(abcxyz, new String[] {null, xyz, abc})", StringUtils.endsWithAny("abcxyz", new String[] {null, "xyz", "abc"})); - assertFalse("StringUtils.endsWithAny(defg, new String[] {null, xyz, abc})", StringUtils.endsWithAny("defg", new String[] {null, "xyz", "abc"})); + assertFalse(StringUtils.endsWithAny(null, (String)null), "StringUtils.endsWithAny(null, null)"); + assertFalse(StringUtils.endsWithAny(null, new String[] {"abc"}), "StringUtils.endsWithAny(null, new String[] {abc})"); + assertFalse(StringUtils.endsWithAny("abcxyz", (String)null), "StringUtils.endsWithAny(abcxyz, null)"); + assertTrue(StringUtils.endsWithAny("abcxyz", new String[] {""}), "StringUtils.endsWithAny(abcxyz, new String[] {\"\"})"); + assertTrue(StringUtils.endsWithAny("abcxyz", new String[] {"xyz"}), "StringUtils.endsWithAny(abcxyz, new String[] {xyz})"); + assertTrue(StringUtils.endsWithAny("abcxyz", new String[] {null, "xyz", "abc"}), "StringUtils.endsWithAny(abcxyz, new String[] {null, xyz, abc})"); + assertFalse(StringUtils.endsWithAny("defg", new String[] {null, "xyz", "abc"}), "StringUtils.endsWithAny(defg, new String[] {null, xyz, abc})"); assertTrue(StringUtils.endsWithAny("abcXYZ", "def", "XYZ")); assertFalse(StringUtils.endsWithAny("abcXYZ", "def", "xyz")); assertTrue(StringUtils.endsWithAny("abcXYZ", "def", "YZ")); @@ -193,8 +193,8 @@ public class StringUtilsStartsEndsWithTest { assertFalse(StringUtils.endsWithAny("abcXYZ", (CharSequence[]) null)); assertTrue(StringUtils.endsWithAny("abcXYZ", "")); - assertTrue("StringUtils.endsWithAny(abcxyz, StringBuilder(abc), StringBuffer(xyz))", StringUtils.endsWithAny("abcxyz", new StringBuilder("abc"), new StringBuffer("xyz"))); - assertTrue("StringUtils.endsWithAny(StringBuffer(abcxyz), StringBuilder(abc), StringBuffer(xyz))", StringUtils.endsWithAny(new StringBuffer("abcxyz"), new StringBuilder("abc"), new StringBuffer("xyz"))); + assertTrue(StringUtils.endsWithAny("abcxyz", new StringBuilder("abc"), new StringBuffer("xyz")), "StringUtils.endsWithAny(abcxyz, StringBuilder(abc), StringBuffer(xyz))"); + assertTrue(StringUtils.endsWithAny(new StringBuffer("abcxyz"), new StringBuilder("abc"), new StringBuffer("xyz")), "StringUtils.endsWithAny(StringBuffer(abcxyz), StringBuilder(abc), StringBuffer(xyz))"); } diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsSubstringTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsSubstringTest.java index 62769f82f..33b7c1328 100644 --- a/src/test/java/org/apache/commons/lang3/StringUtilsSubstringTest.java +++ b/src/test/java/org/apache/commons/lang3/StringUtilsSubstringTest.java @@ -16,11 +16,11 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertSame; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Unit tests {@link org.apache.commons.lang3.StringUtils} - Substring methods diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsTest.java index 04aecaea7..36e310d59 100644 --- a/src/test/java/org/apache/commons/lang3/StringUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/StringUtilsTest.java @@ -16,14 +16,15 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +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.UnsupportedEncodingException; import java.lang.reflect.Constructor; @@ -40,7 +41,7 @@ import java.util.Objects; import java.util.regex.PatternSyntaxException; import org.apache.commons.lang3.text.WordUtils; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Unit tests for methods of {@link org.apache.commons.lang3.StringUtils} @@ -135,45 +136,35 @@ public class StringUtilsTest { public void testUpperCase() { assertNull(StringUtils.upperCase(null)); assertNull(StringUtils.upperCase(null, Locale.ENGLISH)); - assertEquals("upperCase(String) failed", - "FOO TEST THING", StringUtils.upperCase("fOo test THING")); - assertEquals("upperCase(empty-string) failed", - "", StringUtils.upperCase("")); - assertEquals("upperCase(String, Locale) failed", - "FOO TEST THING", StringUtils.upperCase("fOo test THING", Locale.ENGLISH)); - assertEquals("upperCase(empty-string, Locale) failed", - "", StringUtils.upperCase("", Locale.ENGLISH)); + assertEquals("FOO TEST THING", StringUtils.upperCase("fOo test THING"), "upperCase(String) failed"); + assertEquals("", StringUtils.upperCase(""), "upperCase(empty-string) failed"); + assertEquals("FOO TEST THING", StringUtils.upperCase("fOo test THING", Locale.ENGLISH), + "upperCase(String, Locale) failed"); + assertEquals("", StringUtils.upperCase("", Locale.ENGLISH), + "upperCase(empty-string, Locale) failed"); } @Test public void testLowerCase() { assertNull(StringUtils.lowerCase(null)); assertNull(StringUtils.lowerCase(null, Locale.ENGLISH)); - assertEquals("lowerCase(String) failed", - "foo test thing", StringUtils.lowerCase("fOo test THING")); - assertEquals("lowerCase(empty-string) failed", - "", StringUtils.lowerCase("")); - assertEquals("lowerCase(String, Locale) failed", - "foo test thing", StringUtils.lowerCase("fOo test THING", Locale.ENGLISH)); - assertEquals("lowerCase(empty-string, Locale) failed", - "", StringUtils.lowerCase("", Locale.ENGLISH)); + assertEquals("foo test thing", StringUtils.lowerCase("fOo test THING"), "lowerCase(String) failed"); + assertEquals("", StringUtils.lowerCase(""), "lowerCase(empty-string) failed"); + assertEquals("foo test thing", StringUtils.lowerCase("fOo test THING", Locale.ENGLISH), + "lowerCase(String, Locale) failed"); + assertEquals("", StringUtils.lowerCase("", Locale.ENGLISH), "lowerCase(empty-string, Locale) failed"); } @Test public void testCapitalize() { assertNull(StringUtils.capitalize(null)); - assertEquals("capitalize(empty-string) failed", - "", StringUtils.capitalize("")); - assertEquals("capitalize(single-char-string) failed", - "X", StringUtils.capitalize("x")); - assertEquals("capitalize(String) failed", - FOO_CAP, StringUtils.capitalize(FOO_CAP)); - assertEquals("capitalize(string) failed", - FOO_CAP, StringUtils.capitalize(FOO_UNCAP)); + assertEquals("", StringUtils.capitalize(""), "capitalize(empty-string) failed"); + assertEquals("X", StringUtils.capitalize("x"), "capitalize(single-char-string) failed"); + assertEquals(FOO_CAP, StringUtils.capitalize(FOO_CAP), "capitalize(String) failed"); + assertEquals(FOO_CAP, StringUtils.capitalize(FOO_UNCAP), "capitalize(string) failed"); - assertEquals("capitalize(String) is not using TitleCase", - "\u01C8", StringUtils.capitalize("\u01C9")); + assertEquals("\u01C8", StringUtils.capitalize("\u01C9"), "capitalize(String) is not using TitleCase"); // Javadoc examples assertNull(StringUtils.capitalize(null)); @@ -187,14 +178,10 @@ public class StringUtilsTest { public void testUnCapitalize() { assertNull(StringUtils.uncapitalize(null)); - assertEquals("uncapitalize(String) failed", - FOO_UNCAP, StringUtils.uncapitalize(FOO_CAP)); - assertEquals("uncapitalize(string) failed", - FOO_UNCAP, StringUtils.uncapitalize(FOO_UNCAP)); - assertEquals("uncapitalize(empty-string) failed", - "", StringUtils.uncapitalize("")); - assertEquals("uncapitalize(single-char-string) failed", - "x", StringUtils.uncapitalize("X")); + assertEquals(FOO_UNCAP, StringUtils.uncapitalize(FOO_CAP), "uncapitalize(String) failed"); + assertEquals(FOO_UNCAP, StringUtils.uncapitalize(FOO_UNCAP), "uncapitalize(string) failed"); + assertEquals("", StringUtils.uncapitalize(""), "uncapitalize(empty-string) failed"); + assertEquals("x", StringUtils.uncapitalize("X"), "uncapitalize(single-char-string) failed"); // Examples from uncapitalize Javadoc assertEquals("cat", StringUtils.uncapitalize("cat")); @@ -205,16 +192,16 @@ public class StringUtilsTest { @Test public void testReCapitalize() { // reflection type of tests: Sentences. - assertEquals("uncapitalize(capitalize(String)) failed", - SENTENCE_UNCAP, StringUtils.uncapitalize(StringUtils.capitalize(SENTENCE_UNCAP))); - assertEquals("capitalize(uncapitalize(String)) failed", - SENTENCE_CAP, StringUtils.capitalize(StringUtils.uncapitalize(SENTENCE_CAP))); + assertEquals(SENTENCE_UNCAP, StringUtils.uncapitalize(StringUtils.capitalize(SENTENCE_UNCAP)), + "uncapitalize(capitalize(String)) failed"); + assertEquals(SENTENCE_CAP, StringUtils.capitalize(StringUtils.uncapitalize(SENTENCE_CAP)), + "capitalize(uncapitalize(String)) failed"); // reflection type of tests: One word. - assertEquals("uncapitalize(capitalize(String)) failed", - FOO_UNCAP, StringUtils.uncapitalize(StringUtils.capitalize(FOO_UNCAP))); - assertEquals("capitalize(uncapitalize(String)) failed", - FOO_CAP, StringUtils.capitalize(StringUtils.uncapitalize(FOO_CAP))); + assertEquals(FOO_UNCAP, StringUtils.uncapitalize(StringUtils.capitalize(FOO_UNCAP)), + "uncapitalize(capitalize(String)) failed"); + assertEquals(FOO_CAP, StringUtils.capitalize(StringUtils.uncapitalize(FOO_CAP)), + "capitalize(uncapitalize(String)) failed"); } @Test @@ -470,9 +457,9 @@ public class StringUtilsTest { assertEquals("ab", StringUtils.joinWith(null, "a", "b")); } - @Test(expected = IllegalArgumentException.class) + @Test public void testJoinWithThrowsException() { - StringUtils.joinWith(",", (Object[]) null); + assertThrows(IllegalArgumentException.class, () -> StringUtils.joinWith(",", (Object[]) null)); } @@ -567,36 +554,36 @@ public class StringUtilsTest { String[] res; // (str, sepStr) res = StringUtils.split(str, sepStr); - assertEquals(msg, 3, res.length); - assertEquals(msg, "a", res[0]); - assertEquals(msg, "b", res[1]); - assertEquals(msg, noMatch + "c", res[2]); + assertEquals(3, res.length, msg); + assertEquals("a", res[0]); + assertEquals("b", res[1]); + assertEquals(noMatch + "c", res[2]); final String str2 = separator + "a" + separator; res = StringUtils.split(str2, sepStr); - assertEquals(msg, 1, res.length); - assertEquals(msg, "a", res[0]); + assertEquals(1, res.length, msg); + assertEquals("a", res[0], msg); res = StringUtils.split(str, sepStr, -1); - assertEquals(msg, 3, res.length); - assertEquals(msg, "a", res[0]); - assertEquals(msg, "b", res[1]); - assertEquals(msg, noMatch + "c", res[2]); + assertEquals(3, res.length, msg); + assertEquals("a", res[0], msg); + assertEquals("b", res[1], msg); + assertEquals(noMatch + "c", res[2], msg); res = StringUtils.split(str, sepStr, 0); - assertEquals(msg, 3, res.length); - assertEquals(msg, "a", res[0]); - assertEquals(msg, "b", res[1]); - assertEquals(msg, noMatch + "c", res[2]); + assertEquals(3, res.length, msg); + assertEquals("a", res[0], msg); + assertEquals("b", res[1], msg); + assertEquals(noMatch + "c", res[2], msg); res = StringUtils.split(str, sepStr, 1); - assertEquals(msg, 1, res.length); - assertEquals(msg, str, res[0]); + assertEquals(1, res.length, msg); + assertEquals(str, res[0], msg); res = StringUtils.split(str, sepStr, 2); - assertEquals(msg, 2, res.length); - assertEquals(msg, "a", res[0]); - assertEquals(msg, str.substring(2), res[1]); + assertEquals(2, res.length, msg); + assertEquals("a", res[0], msg); + assertEquals(str.substring(2), res[1], msg); } @Test @@ -1067,41 +1054,41 @@ public class StringUtilsTest { String[] res; // (str, sepStr) res = StringUtils.splitPreserveAllTokens(str, sepStr); - assertEquals(msg, 4, res.length); - assertEquals(msg, "a", res[0]); - assertEquals(msg, "b", res[1]); - assertEquals(msg, "", res[2]); - assertEquals(msg, noMatch + "c", res[3]); + assertEquals(4, res.length, msg); + assertEquals("a", res[0], msg); + assertEquals("b", res[1], msg); + assertEquals("", res[2], msg); + assertEquals(noMatch + "c", res[3], msg); final String str2 = separator + "a" + separator; res = StringUtils.splitPreserveAllTokens(str2, sepStr); - assertEquals(msg, 3, res.length); - assertEquals(msg, "", res[0]); - assertEquals(msg, "a", res[1]); - assertEquals(msg, "", res[2]); + assertEquals(3, res.length, msg); + assertEquals("", res[0], msg); + assertEquals("a", res[1], msg); + assertEquals("", res[2], msg); res = StringUtils.splitPreserveAllTokens(str, sepStr, -1); - assertEquals(msg, 4, res.length); - assertEquals(msg, "a", res[0]); - assertEquals(msg, "b", res[1]); - assertEquals(msg, "", res[2]); - assertEquals(msg, noMatch + "c", res[3]); + assertEquals(4, res.length, msg); + assertEquals("a", res[0], msg); + assertEquals("b", res[1], msg); + assertEquals("", res[2], msg); + assertEquals(noMatch + "c", res[3], msg); res = StringUtils.splitPreserveAllTokens(str, sepStr, 0); - assertEquals(msg, 4, res.length); - assertEquals(msg, "a", res[0]); - assertEquals(msg, "b", res[1]); - assertEquals(msg, "", res[2]); - assertEquals(msg, noMatch + "c", res[3]); + assertEquals(4, res.length, msg); + assertEquals("a", res[0], msg); + assertEquals("b", res[1], msg); + assertEquals("", res[2], msg); + assertEquals(noMatch + "c", res[3], msg); res = StringUtils.splitPreserveAllTokens(str, sepStr, 1); - assertEquals(msg, 1, res.length); - assertEquals(msg, str, res[0]); + assertEquals(1, res.length, msg); + assertEquals(str, res[0], msg); res = StringUtils.splitPreserveAllTokens(str, sepStr, 2); - assertEquals(msg, 2, res.length); - assertEquals(msg, "a", res[0]); - assertEquals(msg, str.substring(2), res[1]); + assertEquals(2, res.length, msg); + assertEquals("a", res[0], msg); + assertEquals(str.substring(2), res[1], msg); } @Test @@ -1635,8 +1622,7 @@ public class StringUtilsTest { for (final String[] chopCase : chopCases) { final String original = chopCase[0]; final String expectedResult = chopCase[1]; - assertEquals("chop(String) failed", - expectedResult, StringUtils.chop(original)); + assertEquals(expectedResult, StringUtils.chop(original), "chop(String) failed"); } } @@ -1664,38 +1650,23 @@ public class StringUtilsTest { for (final String[] chompCase : chompCases) { final String original = chompCase[0]; final String expectedResult = chompCase[1]; - assertEquals("chomp(String) failed", - expectedResult, StringUtils.chomp(original)); + assertEquals(expectedResult, StringUtils.chomp(original), "chomp(String) failed"); } - assertEquals("chomp(String, String) failed", - "foo", StringUtils.chomp("foobar", "bar")); - assertEquals("chomp(String, String) failed", - "foobar", StringUtils.chomp("foobar", "baz")); - assertEquals("chomp(String, String) failed", - "foo", StringUtils.chomp("foo", "foooo")); - assertEquals("chomp(String, String) failed", - "foobar", StringUtils.chomp("foobar", "")); - assertEquals("chomp(String, String) failed", - "foobar", StringUtils.chomp("foobar", null)); - assertEquals("chomp(String, String) failed", - "", StringUtils.chomp("", "foo")); - assertEquals("chomp(String, String) failed", - "", StringUtils.chomp("", null)); - assertEquals("chomp(String, String) failed", - "", StringUtils.chomp("", "")); - assertEquals("chomp(String, String) failed", - null, StringUtils.chomp(null, "foo")); - assertEquals("chomp(String, String) failed", - null, StringUtils.chomp(null, null)); - assertEquals("chomp(String, String) failed", - null, StringUtils.chomp(null, "")); - assertEquals("chomp(String, String) failed", - "", StringUtils.chomp("foo", "foo")); - assertEquals("chomp(String, String) failed", - " ", StringUtils.chomp(" foo", "foo")); - assertEquals("chomp(String, String) failed", - "foo ", StringUtils.chomp("foo ", "foo")); + assertEquals("foo", StringUtils.chomp("foobar", "bar"), "chomp(String, String) failed"); + assertEquals("foobar", StringUtils.chomp("foobar", "baz"), "chomp(String, String) failed"); + assertEquals("foo", StringUtils.chomp("foo", "foooo"), "chomp(String, String) failed"); + assertEquals("foobar", StringUtils.chomp("foobar", ""), "chomp(String, String) failed"); + assertEquals("foobar", StringUtils.chomp("foobar", null), "chomp(String, String) failed"); + assertEquals("", StringUtils.chomp("", "foo"), "chomp(String, String) failed"); + assertEquals("", StringUtils.chomp("", null), "chomp(String, String) failed"); + assertEquals("", StringUtils.chomp("", ""), "chomp(String, String) failed"); + assertEquals(null, StringUtils.chomp(null, "foo"), "chomp(String, String) failed"); + assertEquals(null, StringUtils.chomp(null, null), "chomp(String, String) failed"); + assertEquals(null, StringUtils.chomp(null, ""), "chomp(String, String) failed"); + assertEquals("", StringUtils.chomp("foo", "foo"), "chomp(String, String) failed"); + assertEquals(" ", StringUtils.chomp(" foo", "foo"), "chomp(String, String) failed"); + assertEquals("foo ", StringUtils.chomp("foo ", "foo"), "chomp(String, String) failed"); } //----------------------------------------------------------------------- @@ -2098,12 +2069,12 @@ public class StringUtilsTest { final String message = "abbreviate(String,int,int) failed"; final String actual = StringUtils.abbreviate(abcdefghijklmno, offset, maxWidth); if (offset >= 0 && offset < abcdefghijklmno.length()) { - assertTrue(message + " -- should contain offset character", - actual.indexOf((char) ('a' + offset)) != -1); + assertTrue(actual.indexOf((char) ('a' + offset)) != -1, + message + " -- should contain offset character"); } - assertTrue(message + " -- should not be greater than maxWidth", - actual.length() <= maxWidth); - assertEquals(message, expected, actual); + assertTrue(actual.length() <= maxWidth, + message + " -- should not be greater than maxWidth"); + assertEquals(expected, actual, message); } @Test @@ -2157,12 +2128,12 @@ public class StringUtilsTest { final String message = "abbreviate(String,String,int,int) failed"; final String actual = StringUtils.abbreviate(abcdefghijklmno, abbrevMarker, offset, maxWidth); if (offset >= 0 && offset < abcdefghijklmno.length()) { - assertTrue(message + " -- should contain offset character", - actual.indexOf((char) ('a' + offset)) != -1); + assertTrue(actual.indexOf((char) ('a' + offset)) != -1, + message + " -- should contain offset character"); } - assertTrue(message + " -- should not be greater than maxWidth", - actual.length() <= maxWidth); - assertEquals(message, expected, actual); + assertTrue(actual.length() <= maxWidth, + message + " -- should not be greater than maxWidth"); + assertEquals(expected, actual, message); } @Test @@ -2426,14 +2397,14 @@ public class StringUtilsTest { assertEquals(1, StringUtils.getLevenshteinDistance("hello", "hallo")); } - @Test(expected = IllegalArgumentException.class) - public void testGetLevenshteinDistance_NullString() throws Exception { - StringUtils.getLevenshteinDistance("a", null); + @Test + public void testGetLevenshteinDistance_NullString() { + assertThrows(IllegalArgumentException.class, () -> StringUtils.getLevenshteinDistance("a", null)); } - @Test(expected = IllegalArgumentException.class) - public void testGetLevenshteinDistance_StringNull() throws Exception { - StringUtils.getLevenshteinDistance(null, "a"); + @Test + public void testGetLevenshteinDistance_StringNull() { + assertThrows(IllegalArgumentException.class, () -> StringUtils.getLevenshteinDistance(null, "a")); } @Test @@ -2500,47 +2471,47 @@ public class StringUtilsTest { assertEquals(1, StringUtils.getLevenshteinDistance("hello", "hallo", Integer.MAX_VALUE)); } - @Test(expected = IllegalArgumentException.class) - public void testGetLevenshteinDistance_NullStringInt() throws Exception { - StringUtils.getLevenshteinDistance(null, "a", 0); + @Test + public void testGetLevenshteinDistance_NullStringInt() { + assertThrows(IllegalArgumentException.class, () -> StringUtils.getLevenshteinDistance(null, "a", 0)); } - @Test(expected = IllegalArgumentException.class) - public void testGetLevenshteinDistance_StringNullInt() throws Exception { - StringUtils.getLevenshteinDistance("a", null, 0); + @Test + public void testGetLevenshteinDistance_StringNullInt() { + assertThrows(IllegalArgumentException.class, () -> StringUtils.getLevenshteinDistance("a", null, 0)); } - @Test(expected = IllegalArgumentException.class) - public void testGetLevenshteinDistance_StringStringNegativeInt() throws Exception { - StringUtils.getLevenshteinDistance("a", "a", -1); + @Test + public void testGetLevenshteinDistance_StringStringNegativeInt() { + assertThrows(IllegalArgumentException.class, () -> StringUtils.getLevenshteinDistance("a", "a", -1)); } @Test public void testGetJaroWinklerDistance_StringString() { - assertEquals(0.93d, StringUtils.getJaroWinklerDistance("frog", "fog"), 0.0d); - assertEquals(0.0d, StringUtils.getJaroWinklerDistance("fly", "ant"), 0.0d); - assertEquals(0.44d, StringUtils.getJaroWinklerDistance("elephant", "hippo"), 0.0d); - assertEquals(0.84d, StringUtils.getJaroWinklerDistance("dwayne", "duane"), 0.0d); - assertEquals(0.93d, StringUtils.getJaroWinklerDistance("ABC Corporation", "ABC Corp"), 0.0d); - assertEquals(0.95d, StringUtils.getJaroWinklerDistance("D N H Enterprises Inc", "D & H Enterprises, Inc."), 0.0d); - assertEquals(0.92d, StringUtils.getJaroWinklerDistance("My Gym Children's Fitness Center", "My Gym. Childrens Fitness"), 0.0d); - assertEquals(0.88d, StringUtils.getJaroWinklerDistance("PENNSYLVANIA", "PENNCISYLVNIA"), 0.0d); - assertEquals(0.63d, StringUtils.getJaroWinklerDistance("Haus Ingeborg", "Ingeborg Esser"), 0.0d); + assertTrue(0.93d == StringUtils.getJaroWinklerDistance("frog", "fog")); + assertTrue(0.0d == StringUtils.getJaroWinklerDistance("fly", "ant")); + assertTrue(0.44d == StringUtils.getJaroWinklerDistance("elephant", "hippo")); + assertTrue(0.84d == StringUtils.getJaroWinklerDistance("dwayne", "duane")); + assertTrue(0.93d == StringUtils.getJaroWinklerDistance("ABC Corporation", "ABC Corp")); + assertTrue(0.95d == StringUtils.getJaroWinklerDistance("D N H Enterprises Inc", "D & H Enterprises, Inc.")); + assertTrue(0.92d == StringUtils.getJaroWinklerDistance("My Gym Children's Fitness Center", "My Gym. Childrens Fitness")); + assertTrue(0.88d == StringUtils.getJaroWinklerDistance("PENNSYLVANIA", "PENNCISYLVNIA")); + assertTrue(0.63d == StringUtils.getJaroWinklerDistance("Haus Ingeborg", "Ingeborg Esser")); } - @Test(expected = IllegalArgumentException.class) - public void testGetJaroWinklerDistance_NullNull() throws Exception { - StringUtils.getJaroWinklerDistance(null, null); + @Test + public void testGetJaroWinklerDistance_NullNull() { + assertThrows(IllegalArgumentException.class, () -> StringUtils.getJaroWinklerDistance(null, null)); } - @Test(expected = IllegalArgumentException.class) - public void testGetJaroWinklerDistance_StringNull() throws Exception { - StringUtils.getJaroWinklerDistance(" ", null); + @Test + public void testGetJaroWinklerDistance_StringNull() { + assertThrows(IllegalArgumentException.class, () -> StringUtils.getJaroWinklerDistance(" ", null)); } - @Test(expected = IllegalArgumentException.class) - public void testGetJaroWinklerDistance_NullString() throws Exception { - StringUtils.getJaroWinklerDistance(null, "clear"); + @Test + public void testGetJaroWinklerDistance_NullString() { + assertThrows(IllegalArgumentException.class, () -> StringUtils.getJaroWinklerDistance(null, "clear")); } @Test @@ -2554,24 +2525,24 @@ public class StringUtilsTest { assertEquals(3, StringUtils.getFuzzyDistance("Apache Software Foundation", "asf", Locale.ENGLISH)); } - @Test(expected = IllegalArgumentException.class) - public void testGetFuzzyDistance_NullNullNull() throws Exception { - StringUtils.getFuzzyDistance(null, null, null); + @Test + public void testGetFuzzyDistance_NullNullNull() { + assertThrows(IllegalArgumentException.class, () -> StringUtils.getFuzzyDistance(null, null, null)); } - @Test(expected = IllegalArgumentException.class) - public void testGetFuzzyDistance_StringNullLoclae() throws Exception { - StringUtils.getFuzzyDistance(" ", null, Locale.ENGLISH); + @Test + public void testGetFuzzyDistance_StringNullLoclae() { + assertThrows(IllegalArgumentException.class, () -> StringUtils.getFuzzyDistance(" ", null, Locale.ENGLISH)); } - @Test(expected = IllegalArgumentException.class) - public void testGetFuzzyDistance_NullStringLocale() throws Exception { - StringUtils.getFuzzyDistance(null, "clear", Locale.ENGLISH); + @Test + public void testGetFuzzyDistance_NullStringLocale() { + assertThrows(IllegalArgumentException.class, () -> StringUtils.getFuzzyDistance(null, "clear", Locale.ENGLISH)); } - @Test(expected = IllegalArgumentException.class) - public void testGetFuzzyDistance_StringStringNull() throws Exception { - StringUtils.getFuzzyDistance(" ", "clear", null); + @Test + public void testGetFuzzyDistance_StringStringNull() { + assertThrows(IllegalArgumentException.class, () -> StringUtils.getFuzzyDistance(" ", "clear", null)); } /** @@ -2663,23 +2634,23 @@ public class StringUtilsTest { @Test public void testRemoveStartIgnoreCase() { // StringUtils.removeStart("", *) = "" - assertNull("removeStartIgnoreCase(null, null)", StringUtils.removeStartIgnoreCase(null, null)); - assertNull("removeStartIgnoreCase(null, \"\")", StringUtils.removeStartIgnoreCase(null, "")); - assertNull("removeStartIgnoreCase(null, \"a\")", StringUtils.removeStartIgnoreCase(null, "a")); + assertNull(StringUtils.removeStartIgnoreCase(null, null), "removeStartIgnoreCase(null, null)"); + assertNull(StringUtils.removeStartIgnoreCase(null, ""), "removeStartIgnoreCase(null, \"\")"); + assertNull(StringUtils.removeStartIgnoreCase(null, "a"), "removeStartIgnoreCase(null, \"a\")"); // StringUtils.removeStart(*, null) = * - assertEquals("removeStartIgnoreCase(\"\", null)", StringUtils.removeStartIgnoreCase("", null), ""); - assertEquals("removeStartIgnoreCase(\"\", \"\")", StringUtils.removeStartIgnoreCase("", ""), ""); - assertEquals("removeStartIgnoreCase(\"\", \"a\")", StringUtils.removeStartIgnoreCase("", "a"), ""); + assertEquals(StringUtils.removeStartIgnoreCase("", null), "", "removeStartIgnoreCase(\"\", null)"); + assertEquals(StringUtils.removeStartIgnoreCase("", ""), "", "removeStartIgnoreCase(\"\", \"\")"); + assertEquals(StringUtils.removeStartIgnoreCase("", "a"), "", "removeStartIgnoreCase(\"\", \"a\")"); // All others: - assertEquals("removeStartIgnoreCase(\"www.domain.com\", \"www.\")", StringUtils.removeStartIgnoreCase("www.domain.com", "www."), "domain.com"); - assertEquals("removeStartIgnoreCase(\"domain.com\", \"www.\")", StringUtils.removeStartIgnoreCase("domain.com", "www."), "domain.com"); - assertEquals("removeStartIgnoreCase(\"domain.com\", \"\")", StringUtils.removeStartIgnoreCase("domain.com", ""), "domain.com"); - assertEquals("removeStartIgnoreCase(\"domain.com\", null)", StringUtils.removeStartIgnoreCase("domain.com", null), "domain.com"); + assertEquals(StringUtils.removeStartIgnoreCase("www.domain.com", "www."), "domain.com", "removeStartIgnoreCase(\"www.domain.com\", \"www.\")"); + assertEquals(StringUtils.removeStartIgnoreCase("domain.com", "www."), "domain.com", "removeStartIgnoreCase(\"domain.com\", \"www.\")"); + assertEquals(StringUtils.removeStartIgnoreCase("domain.com", ""), "domain.com", "removeStartIgnoreCase(\"domain.com\", \"\")"); + assertEquals(StringUtils.removeStartIgnoreCase("domain.com", null), "domain.com", "removeStartIgnoreCase(\"domain.com\", null)"); // Case insensitive: - assertEquals("removeStartIgnoreCase(\"www.domain.com\", \"WWW.\")", StringUtils.removeStartIgnoreCase("www.domain.com", "WWW."), "domain.com"); + assertEquals(StringUtils.removeStartIgnoreCase("www.domain.com", "WWW."), "domain.com", "removeStartIgnoreCase(\"www.domain.com\", \"WWW.\")"); } @Test @@ -2705,25 +2676,25 @@ public class StringUtilsTest { @Test public void testRemoveEndIgnoreCase() { // StringUtils.removeEndIgnoreCase("", *) = "" - assertNull("removeEndIgnoreCase(null, null)", StringUtils.removeEndIgnoreCase(null, null)); - assertNull("removeEndIgnoreCase(null, \"\")", StringUtils.removeEndIgnoreCase(null, "")); - assertNull("removeEndIgnoreCase(null, \"a\")", StringUtils.removeEndIgnoreCase(null, "a")); + assertNull(StringUtils.removeEndIgnoreCase(null, null), "removeEndIgnoreCase(null, null)"); + assertNull(StringUtils.removeEndIgnoreCase(null, ""), "removeEndIgnoreCase(null, \"\")"); + assertNull(StringUtils.removeEndIgnoreCase(null, "a"), "removeEndIgnoreCase(null, \"a\")"); // StringUtils.removeEnd(*, null) = * - assertEquals("removeEndIgnoreCase(\"\", null)", StringUtils.removeEndIgnoreCase("", null), ""); - assertEquals("removeEndIgnoreCase(\"\", \"\")", StringUtils.removeEndIgnoreCase("", ""), ""); - assertEquals("removeEndIgnoreCase(\"\", \"a\")", StringUtils.removeEndIgnoreCase("", "a"), ""); + assertEquals(StringUtils.removeEndIgnoreCase("", null), "", "removeEndIgnoreCase(\"\", null)"); + assertEquals(StringUtils.removeEndIgnoreCase("", ""), "", "removeEndIgnoreCase(\"\", \"\")"); + assertEquals(StringUtils.removeEndIgnoreCase("", "a"), "", "removeEndIgnoreCase(\"\", \"a\")"); // All others: - assertEquals("removeEndIgnoreCase(\"www.domain.com.\", \".com\")", StringUtils.removeEndIgnoreCase("www.domain.com.", ".com"), "www.domain.com."); - assertEquals("removeEndIgnoreCase(\"www.domain.com\", \".com\")", StringUtils.removeEndIgnoreCase("www.domain.com", ".com"), "www.domain"); - assertEquals("removeEndIgnoreCase(\"www.domain\", \".com\")", StringUtils.removeEndIgnoreCase("www.domain", ".com"), "www.domain"); - assertEquals("removeEndIgnoreCase(\"domain.com\", \"\")", StringUtils.removeEndIgnoreCase("domain.com", ""), "domain.com"); - assertEquals("removeEndIgnoreCase(\"domain.com\", null)", StringUtils.removeEndIgnoreCase("domain.com", null), "domain.com"); + assertEquals(StringUtils.removeEndIgnoreCase("www.domain.com.", ".com"), "www.domain.com.", "removeEndIgnoreCase(\"www.domain.com.\", \".com\")"); + assertEquals(StringUtils.removeEndIgnoreCase("www.domain.com", ".com"), "www.domain", "removeEndIgnoreCase(\"www.domain.com\", \".com\")"); + assertEquals(StringUtils.removeEndIgnoreCase("www.domain", ".com"), "www.domain", "removeEndIgnoreCase(\"www.domain\", \".com\")"); + assertEquals(StringUtils.removeEndIgnoreCase("domain.com", ""), "domain.com", "removeEndIgnoreCase(\"domain.com\", \"\")"); + assertEquals(StringUtils.removeEndIgnoreCase("domain.com", null), "domain.com", "removeEndIgnoreCase(\"domain.com\", null)"); // Case insensitive: - assertEquals("removeEndIgnoreCase(\"www.domain.com\", \".COM\")", StringUtils.removeEndIgnoreCase("www.domain.com", ".COM"), "www.domain"); - assertEquals("removeEndIgnoreCase(\"www.domain.COM\", \".com\")", StringUtils.removeEndIgnoreCase("www.domain.COM", ".com"), "www.domain"); + assertEquals(StringUtils.removeEndIgnoreCase("www.domain.com", ".COM"), "www.domain", "removeEndIgnoreCase(\"www.domain.com\", \".COM\")"); + assertEquals(StringUtils.removeEndIgnoreCase("www.domain.COM", ".com"), "www.domain", "removeEndIgnoreCase(\"www.domain.COM\", \".com\")"); } @Test @@ -3028,23 +2999,23 @@ public class StringUtilsTest { */ @Test public void testAppendIfMissing() { - assertEquals("appendIfMissing(null,null)", null, StringUtils.appendIfMissing(null, null)); - assertEquals("appendIfMissing(abc,null)", "abc", StringUtils.appendIfMissing("abc", null)); - assertEquals("appendIfMissing(\"\",xyz)", "xyz", StringUtils.appendIfMissing("", "xyz")); - assertEquals("appendIfMissing(abc,xyz)", "abcxyz", StringUtils.appendIfMissing("abc", "xyz")); - assertEquals("appendIfMissing(abcxyz,xyz)", "abcxyz", StringUtils.appendIfMissing("abcxyz", "xyz")); - assertEquals("appendIfMissing(aXYZ,xyz)", "aXYZxyz", StringUtils.appendIfMissing("aXYZ", "xyz")); + assertEquals(null, StringUtils.appendIfMissing(null, null), "appendIfMissing(null,null)"); + assertEquals("abc", StringUtils.appendIfMissing("abc", null), "appendIfMissing(abc,null)"); + assertEquals("xyz", StringUtils.appendIfMissing("", "xyz"), "appendIfMissing(\"\",xyz)"); + assertEquals("abcxyz", StringUtils.appendIfMissing("abc", "xyz"), "appendIfMissing(abc,xyz)"); + assertEquals("abcxyz", StringUtils.appendIfMissing("abcxyz", "xyz"), "appendIfMissing(abcxyz,xyz)"); + assertEquals("aXYZxyz", StringUtils.appendIfMissing("aXYZ", "xyz"), "appendIfMissing(aXYZ,xyz)"); - assertEquals("appendIfMissing(null,null,null)", null, StringUtils.appendIfMissing(null, null, (CharSequence[]) null)); - assertEquals("appendIfMissing(abc,null,null)", "abc", StringUtils.appendIfMissing("abc", null, (CharSequence[]) null)); - assertEquals("appendIfMissing(\"\",xyz,null))", "xyz", StringUtils.appendIfMissing("", "xyz", (CharSequence[]) null)); - assertEquals("appendIfMissing(abc,xyz,{null})", "abcxyz", StringUtils.appendIfMissing("abc", "xyz", new CharSequence[]{null})); - assertEquals("appendIfMissing(abc,xyz,\"\")", "abc", StringUtils.appendIfMissing("abc", "xyz", "")); - assertEquals("appendIfMissing(abc,xyz,mno)", "abcxyz", StringUtils.appendIfMissing("abc", "xyz", "mno")); - assertEquals("appendIfMissing(abcxyz,xyz,mno)", "abcxyz", StringUtils.appendIfMissing("abcxyz", "xyz", "mno")); - assertEquals("appendIfMissing(abcmno,xyz,mno)", "abcmno", StringUtils.appendIfMissing("abcmno", "xyz", "mno")); - assertEquals("appendIfMissing(abcXYZ,xyz,mno)", "abcXYZxyz", StringUtils.appendIfMissing("abcXYZ", "xyz", "mno")); - assertEquals("appendIfMissing(abcMNO,xyz,mno)", "abcMNOxyz", StringUtils.appendIfMissing("abcMNO", "xyz", "mno")); + assertEquals(null, StringUtils.appendIfMissing(null, null, (CharSequence[]) null), "appendIfMissing(null,null,null)"); + assertEquals("abc", StringUtils.appendIfMissing("abc", null, (CharSequence[]) null), "appendIfMissing(abc,null,null)"); + assertEquals("xyz", StringUtils.appendIfMissing("", "xyz", (CharSequence[]) null), "appendIfMissing(\"\",xyz,null))"); + assertEquals("abcxyz", StringUtils.appendIfMissing("abc", "xyz", new CharSequence[]{null}), "appendIfMissing(abc,xyz,{null})"); + assertEquals("abc", StringUtils.appendIfMissing("abc", "xyz", ""), "appendIfMissing(abc,xyz,\"\")"); + assertEquals("abcxyz", StringUtils.appendIfMissing("abc", "xyz", "mno"), "appendIfMissing(abc,xyz,mno)"); + assertEquals("abcxyz", StringUtils.appendIfMissing("abcxyz", "xyz", "mno"), "appendIfMissing(abcxyz,xyz,mno)"); + assertEquals("abcmno", StringUtils.appendIfMissing("abcmno", "xyz", "mno"), "appendIfMissing(abcmno,xyz,mno)"); + assertEquals("abcXYZxyz", StringUtils.appendIfMissing("abcXYZ", "xyz", "mno"), "appendIfMissing(abcXYZ,xyz,mno)"); + assertEquals("abcMNOxyz", StringUtils.appendIfMissing("abcMNO", "xyz", "mno"), "appendIfMissing(abcMNO,xyz,mno)"); } /** @@ -3052,23 +3023,23 @@ public class StringUtilsTest { */ @Test public void testAppendIfMissingIgnoreCase() { - assertEquals("appendIfMissingIgnoreCase(null,null)", null, StringUtils.appendIfMissingIgnoreCase(null, null)); - assertEquals("appendIfMissingIgnoreCase(abc,null)", "abc", StringUtils.appendIfMissingIgnoreCase("abc", null)); - assertEquals("appendIfMissingIgnoreCase(\"\",xyz)", "xyz", StringUtils.appendIfMissingIgnoreCase("", "xyz")); - assertEquals("appendIfMissingIgnoreCase(abc,xyz)", "abcxyz", StringUtils.appendIfMissingIgnoreCase("abc", "xyz")); - assertEquals("appendIfMissingIgnoreCase(abcxyz,xyz)", "abcxyz", StringUtils.appendIfMissingIgnoreCase("abcxyz", "xyz")); - assertEquals("appendIfMissingIgnoreCase(abcXYZ,xyz)", "abcXYZ", StringUtils.appendIfMissingIgnoreCase("abcXYZ", "xyz")); + assertEquals(null, StringUtils.appendIfMissingIgnoreCase(null, null), "appendIfMissingIgnoreCase(null,null)"); + assertEquals("abc", StringUtils.appendIfMissingIgnoreCase("abc", null), "appendIfMissingIgnoreCase(abc,null)"); + assertEquals("xyz", StringUtils.appendIfMissingIgnoreCase("", "xyz"), "appendIfMissingIgnoreCase(\"\",xyz)"); + assertEquals("abcxyz", StringUtils.appendIfMissingIgnoreCase("abc", "xyz"), "appendIfMissingIgnoreCase(abc,xyz)"); + assertEquals("abcxyz", StringUtils.appendIfMissingIgnoreCase("abcxyz", "xyz"), "appendIfMissingIgnoreCase(abcxyz,xyz)"); + assertEquals("abcXYZ", StringUtils.appendIfMissingIgnoreCase("abcXYZ", "xyz"), "appendIfMissingIgnoreCase(abcXYZ,xyz)"); - assertEquals("appendIfMissingIgnoreCase(null,null,null)", null, StringUtils.appendIfMissingIgnoreCase(null, null, (CharSequence[]) null)); - assertEquals("appendIfMissingIgnoreCase(abc,null,null)", "abc", StringUtils.appendIfMissingIgnoreCase("abc", null, (CharSequence[]) null)); - assertEquals("appendIfMissingIgnoreCase(\"\",xyz,null)", "xyz", StringUtils.appendIfMissingIgnoreCase("", "xyz", (CharSequence[]) null)); - assertEquals("appendIfMissingIgnoreCase(abc,xyz,{null})", "abcxyz", StringUtils.appendIfMissingIgnoreCase("abc", "xyz", new CharSequence[]{null})); - assertEquals("appendIfMissingIgnoreCase(abc,xyz,\"\")", "abc", StringUtils.appendIfMissingIgnoreCase("abc", "xyz", "")); - assertEquals("appendIfMissingIgnoreCase(abc,xyz,mno)", "abcxyz", StringUtils.appendIfMissingIgnoreCase("abc", "xyz", "mno")); - assertEquals("appendIfMissingIgnoreCase(abcxyz,xyz,mno)", "abcxyz", StringUtils.appendIfMissingIgnoreCase("abcxyz", "xyz", "mno")); - assertEquals("appendIfMissingIgnoreCase(abcmno,xyz,mno)", "abcmno", StringUtils.appendIfMissingIgnoreCase("abcmno", "xyz", "mno")); - assertEquals("appendIfMissingIgnoreCase(abcXYZ,xyz,mno)", "abcXYZ", StringUtils.appendIfMissingIgnoreCase("abcXYZ", "xyz", "mno")); - assertEquals("appendIfMissingIgnoreCase(abcMNO,xyz,mno)", "abcMNO", StringUtils.appendIfMissingIgnoreCase("abcMNO", "xyz", "mno")); + assertEquals(null, StringUtils.appendIfMissingIgnoreCase(null, null, (CharSequence[]) null), "appendIfMissingIgnoreCase(null,null,null)"); + assertEquals("abc", StringUtils.appendIfMissingIgnoreCase("abc", null, (CharSequence[]) null), "appendIfMissingIgnoreCase(abc,null,null)"); + assertEquals("xyz", StringUtils.appendIfMissingIgnoreCase("", "xyz", (CharSequence[]) null), "appendIfMissingIgnoreCase(\"\",xyz,null)"); + assertEquals("abcxyz", StringUtils.appendIfMissingIgnoreCase("abc", "xyz", new CharSequence[]{null}), "appendIfMissingIgnoreCase(abc,xyz,{null})"); + assertEquals("abc", StringUtils.appendIfMissingIgnoreCase("abc", "xyz", ""), "appendIfMissingIgnoreCase(abc,xyz,\"\")"); + assertEquals("abcxyz", StringUtils.appendIfMissingIgnoreCase("abc", "xyz", "mno"), "appendIfMissingIgnoreCase(abc,xyz,mno)"); + assertEquals("abcxyz", StringUtils.appendIfMissingIgnoreCase("abcxyz", "xyz", "mno"), "appendIfMissingIgnoreCase(abcxyz,xyz,mno)"); + assertEquals("abcmno", StringUtils.appendIfMissingIgnoreCase("abcmno", "xyz", "mno"), "appendIfMissingIgnoreCase(abcmno,xyz,mno)"); + assertEquals("abcXYZ", StringUtils.appendIfMissingIgnoreCase("abcXYZ", "xyz", "mno"), "appendIfMissingIgnoreCase(abcXYZ,xyz,mno)"); + assertEquals("abcMNO", StringUtils.appendIfMissingIgnoreCase("abcMNO", "xyz", "mno"), "appendIfMissingIgnoreCase(abcMNO,xyz,mno)"); } /** @@ -3076,23 +3047,23 @@ public class StringUtilsTest { */ @Test public void testPrependIfMissing() { - assertEquals("prependIfMissing(null,null)", null, StringUtils.prependIfMissing(null, null)); - assertEquals("prependIfMissing(abc,null)", "abc", StringUtils.prependIfMissing("abc", null)); - assertEquals("prependIfMissing(\"\",xyz)", "xyz", StringUtils.prependIfMissing("", "xyz")); - assertEquals("prependIfMissing(abc,xyz)", "xyzabc", StringUtils.prependIfMissing("abc", "xyz")); - assertEquals("prependIfMissing(xyzabc,xyz)", "xyzabc", StringUtils.prependIfMissing("xyzabc", "xyz")); - assertEquals("prependIfMissing(XYZabc,xyz)", "xyzXYZabc", StringUtils.prependIfMissing("XYZabc", "xyz")); + assertEquals(null, StringUtils.prependIfMissing(null, null), "prependIfMissing(null,null)"); + assertEquals("abc", StringUtils.prependIfMissing("abc", null), "prependIfMissing(abc,null)"); + assertEquals("xyz", StringUtils.prependIfMissing("", "xyz"), "prependIfMissing(\"\",xyz)"); + assertEquals("xyzabc", StringUtils.prependIfMissing("abc", "xyz"), "prependIfMissing(abc,xyz)"); + assertEquals("xyzabc", StringUtils.prependIfMissing("xyzabc", "xyz"), "prependIfMissing(xyzabc,xyz)"); + assertEquals("xyzXYZabc", StringUtils.prependIfMissing("XYZabc", "xyz"), "prependIfMissing(XYZabc,xyz)"); - assertEquals("prependIfMissing(null,null null)", null, StringUtils.prependIfMissing(null, null, (CharSequence[]) null)); - assertEquals("prependIfMissing(abc,null,null)", "abc", StringUtils.prependIfMissing("abc", null, (CharSequence[]) null)); - assertEquals("prependIfMissing(\"\",xyz,null)", "xyz", StringUtils.prependIfMissing("", "xyz", (CharSequence[]) null)); - assertEquals("prependIfMissing(abc,xyz,{null})", "xyzabc", StringUtils.prependIfMissing("abc", "xyz", new CharSequence[]{null})); - assertEquals("prependIfMissing(abc,xyz,\"\")", "abc", StringUtils.prependIfMissing("abc", "xyz", "")); - assertEquals("prependIfMissing(abc,xyz,mno)", "xyzabc", StringUtils.prependIfMissing("abc", "xyz", "mno")); - assertEquals("prependIfMissing(xyzabc,xyz,mno)", "xyzabc", StringUtils.prependIfMissing("xyzabc", "xyz", "mno")); - assertEquals("prependIfMissing(mnoabc,xyz,mno)", "mnoabc", StringUtils.prependIfMissing("mnoabc", "xyz", "mno")); - assertEquals("prependIfMissing(XYZabc,xyz,mno)", "xyzXYZabc", StringUtils.prependIfMissing("XYZabc", "xyz", "mno")); - assertEquals("prependIfMissing(MNOabc,xyz,mno)", "xyzMNOabc", StringUtils.prependIfMissing("MNOabc", "xyz", "mno")); + assertEquals(null, StringUtils.prependIfMissing(null, null, (CharSequence[]) null), "prependIfMissing(null,null null)"); + assertEquals("abc", StringUtils.prependIfMissing("abc", null, (CharSequence[]) null), "prependIfMissing(abc,null,null)"); + assertEquals("xyz", StringUtils.prependIfMissing("", "xyz", (CharSequence[]) null), "prependIfMissing(\"\",xyz,null)"); + assertEquals("xyzabc", StringUtils.prependIfMissing("abc", "xyz", new CharSequence[]{null}), "prependIfMissing(abc,xyz,{null})"); + assertEquals("abc", StringUtils.prependIfMissing("abc", "xyz", ""), "prependIfMissing(abc,xyz,\"\")"); + assertEquals("xyzabc", StringUtils.prependIfMissing("abc", "xyz", "mno"), "prependIfMissing(abc,xyz,mno)"); + assertEquals("xyzabc", StringUtils.prependIfMissing("xyzabc", "xyz", "mno"), "prependIfMissing(xyzabc,xyz,mno)"); + assertEquals("mnoabc", StringUtils.prependIfMissing("mnoabc", "xyz", "mno"), "prependIfMissing(mnoabc,xyz,mno)"); + assertEquals("xyzXYZabc", StringUtils.prependIfMissing("XYZabc", "xyz", "mno"), "prependIfMissing(XYZabc,xyz,mno)"); + assertEquals("xyzMNOabc", StringUtils.prependIfMissing("MNOabc", "xyz", "mno"), "prependIfMissing(MNOabc,xyz,mno)"); } /** @@ -3100,23 +3071,23 @@ public class StringUtilsTest { */ @Test public void testPrependIfMissingIgnoreCase() { - assertEquals("prependIfMissingIgnoreCase(null,null)", null, StringUtils.prependIfMissingIgnoreCase(null, null)); - assertEquals("prependIfMissingIgnoreCase(abc,null)", "abc", StringUtils.prependIfMissingIgnoreCase("abc", null)); - assertEquals("prependIfMissingIgnoreCase(\"\",xyz)", "xyz", StringUtils.prependIfMissingIgnoreCase("", "xyz")); - assertEquals("prependIfMissingIgnoreCase(abc,xyz)", "xyzabc", StringUtils.prependIfMissingIgnoreCase("abc", "xyz")); - assertEquals("prependIfMissingIgnoreCase(xyzabc,xyz)", "xyzabc", StringUtils.prependIfMissingIgnoreCase("xyzabc", "xyz")); - assertEquals("prependIfMissingIgnoreCase(XYZabc,xyz)", "XYZabc", StringUtils.prependIfMissingIgnoreCase("XYZabc", "xyz")); + assertEquals(null, StringUtils.prependIfMissingIgnoreCase(null, null), "prependIfMissingIgnoreCase(null,null)"); + assertEquals("abc", StringUtils.prependIfMissingIgnoreCase("abc", null), "prependIfMissingIgnoreCase(abc,null)"); + assertEquals("xyz", StringUtils.prependIfMissingIgnoreCase("", "xyz"), "prependIfMissingIgnoreCase(\"\",xyz)"); + assertEquals("xyzabc", StringUtils.prependIfMissingIgnoreCase("abc", "xyz"), "prependIfMissingIgnoreCase(abc,xyz)"); + assertEquals("xyzabc", StringUtils.prependIfMissingIgnoreCase("xyzabc", "xyz"), "prependIfMissingIgnoreCase(xyzabc,xyz)"); + assertEquals("XYZabc", StringUtils.prependIfMissingIgnoreCase("XYZabc", "xyz"), "prependIfMissingIgnoreCase(XYZabc,xyz)"); - assertEquals("prependIfMissingIgnoreCase(null,null null)", null, StringUtils.prependIfMissingIgnoreCase(null, null, (CharSequence[]) null)); - assertEquals("prependIfMissingIgnoreCase(abc,null,null)", "abc", StringUtils.prependIfMissingIgnoreCase("abc", null, (CharSequence[]) null)); - assertEquals("prependIfMissingIgnoreCase(\"\",xyz,null)", "xyz", StringUtils.prependIfMissingIgnoreCase("", "xyz", (CharSequence[]) null)); - assertEquals("prependIfMissingIgnoreCase(abc,xyz,{null})", "xyzabc", StringUtils.prependIfMissingIgnoreCase("abc", "xyz", new CharSequence[]{null})); - assertEquals("prependIfMissingIgnoreCase(abc,xyz,\"\")", "abc", StringUtils.prependIfMissingIgnoreCase("abc", "xyz", "")); - assertEquals("prependIfMissingIgnoreCase(abc,xyz,mno)", "xyzabc", StringUtils.prependIfMissingIgnoreCase("abc", "xyz", "mno")); - assertEquals("prependIfMissingIgnoreCase(xyzabc,xyz,mno)", "xyzabc", StringUtils.prependIfMissingIgnoreCase("xyzabc", "xyz", "mno")); - assertEquals("prependIfMissingIgnoreCase(mnoabc,xyz,mno)", "mnoabc", StringUtils.prependIfMissingIgnoreCase("mnoabc", "xyz", "mno")); - assertEquals("prependIfMissingIgnoreCase(XYZabc,xyz,mno)", "XYZabc", StringUtils.prependIfMissingIgnoreCase("XYZabc", "xyz", "mno")); - assertEquals("prependIfMissingIgnoreCase(MNOabc,xyz,mno)", "MNOabc", StringUtils.prependIfMissingIgnoreCase("MNOabc", "xyz", "mno")); + assertEquals(null, StringUtils.prependIfMissingIgnoreCase(null, null, (CharSequence[]) null), "prependIfMissingIgnoreCase(null,null null)"); + assertEquals("abc", StringUtils.prependIfMissingIgnoreCase("abc", null, (CharSequence[]) null), "prependIfMissingIgnoreCase(abc,null,null)"); + assertEquals("xyz", StringUtils.prependIfMissingIgnoreCase("", "xyz", (CharSequence[]) null), "prependIfMissingIgnoreCase(\"\",xyz,null)"); + assertEquals("xyzabc", StringUtils.prependIfMissingIgnoreCase("abc", "xyz", new CharSequence[]{null}), "prependIfMissingIgnoreCase(abc,xyz,{null})"); + assertEquals("abc", StringUtils.prependIfMissingIgnoreCase("abc", "xyz", ""), "prependIfMissingIgnoreCase(abc,xyz,\"\")"); + assertEquals("xyzabc", StringUtils.prependIfMissingIgnoreCase("abc", "xyz", "mno"), "prependIfMissingIgnoreCase(abc,xyz,mno)"); + assertEquals("xyzabc", StringUtils.prependIfMissingIgnoreCase("xyzabc", "xyz", "mno"), "prependIfMissingIgnoreCase(xyzabc,xyz,mno)"); + assertEquals("mnoabc", StringUtils.prependIfMissingIgnoreCase("mnoabc", "xyz", "mno"), "prependIfMissingIgnoreCase(mnoabc,xyz,mno)"); + assertEquals("XYZabc", StringUtils.prependIfMissingIgnoreCase("XYZabc", "xyz", "mno"), "prependIfMissingIgnoreCase(XYZabc,xyz,mno)"); + assertEquals("MNOabc", StringUtils.prependIfMissingIgnoreCase("MNOabc", "xyz", "mno"), "prependIfMissingIgnoreCase(MNOabc,xyz,mno)"); } /** diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsTrimStripTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsTrimStripTest.java index 925652751..1cd136e4e 100644 --- a/src/test/java/org/apache/commons/lang3/StringUtilsTrimStripTest.java +++ b/src/test/java/org/apache/commons/lang3/StringUtilsTrimStripTest.java @@ -16,11 +16,11 @@ */ package org.apache.commons.lang3; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Unit tests {@link org.apache.commons.lang3.StringUtils} - Trim/Strip methods @@ -220,19 +220,19 @@ public class StringUtilsTrimStripTest { @Test public void testStripAccents() { final String cue = "\u00C7\u00FA\u00EA"; - assertEquals( "Failed to strip accents from " + cue, "Cue", StringUtils.stripAccents(cue)); + assertEquals("Cue", StringUtils.stripAccents(cue), "Failed to strip accents from " + cue); final String lots = "\u00C0\u00C1\u00C2\u00C3\u00C4\u00C5\u00C7\u00C8\u00C9" + "\u00CA\u00CB\u00CC\u00CD\u00CE\u00CF\u00D1\u00D2\u00D3" + "\u00D4\u00D5\u00D6\u00D9\u00DA\u00DB\u00DC\u00DD"; - assertEquals( "Failed to strip accents from " + lots, - "AAAAAACEEEEIIIINOOOOOUUUUY", - StringUtils.stripAccents(lots)); + assertEquals("AAAAAACEEEEIIIINOOOOOUUUUY", + StringUtils.stripAccents(lots), + "Failed to strip accents from " + lots); - assertNull( "Failed null safety", StringUtils.stripAccents(null) ); - assertEquals( "Failed empty String", "", StringUtils.stripAccents("") ); - assertEquals( "Failed to handle non-accented text", "control", StringUtils.stripAccents("control") ); - assertEquals( "Failed to handle easy example", "eclair", StringUtils.stripAccents("\u00E9clair") ); + assertNull(StringUtils.stripAccents(null), "Failed null safety"); + assertEquals("", StringUtils.stripAccents(""), "Failed empty String"); + assertEquals("control", StringUtils.stripAccents("control"), "Failed to handle non-accented text"); + assertEquals("eclair", StringUtils.stripAccents("\u00E9clair"), "Failed to handle easy example"); assertEquals("ALOSZZCN aloszzcn", StringUtils.stripAccents("\u0104\u0141\u00D3\u015A\u017B\u0179\u0106\u0143 " + "\u0105\u0142\u00F3\u015B\u017C\u017A\u0107\u0144")); } diff --git a/src/test/java/org/apache/commons/lang3/SystemUtilsTest.java b/src/test/java/org/apache/commons/lang3/SystemUtilsTest.java index 572a46e9c..f5cd4674a 100644 --- a/src/test/java/org/apache/commons/lang3/SystemUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/SystemUtilsTest.java @@ -30,18 +30,18 @@ import static org.apache.commons.lang3.JavaVersion.JAVA_1_8; import static org.apache.commons.lang3.JavaVersion.JAVA_9; import static org.apache.commons.lang3.JavaVersion.JAVA_10; import static org.apache.commons.lang3.JavaVersion.JAVA_11; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.File; import java.lang.reflect.Constructor; import java.lang.reflect.Modifier; import java.util.Locale; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Unit tests {@link org.apache.commons.lang3.SystemUtils}. @@ -64,7 +64,7 @@ public class SystemUtilsTest { public void testGetEnvironmentVariableAbsent() { final String name = "THIS_ENV_VAR_SHOULD_NOT_EXIST_FOR_THIS_TEST_TO_PASS"; final String expected = System.getenv(name); - Assert.assertNull(expected); + assertNull(expected); final String value = SystemUtils.getEnvironmentVariable(name, "DEFAULT"); assertEquals("DEFAULT", value); } diff --git a/src/test/java/org/apache/commons/lang3/ThreadUtilsTest.java b/src/test/java/org/apache/commons/lang3/ThreadUtilsTest.java index 63b11652f..abc1a8db1 100644 --- a/src/test/java/org/apache/commons/lang3/ThreadUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/ThreadUtilsTest.java @@ -19,12 +19,13 @@ package org.apache.commons.lang3; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.lang.reflect.Constructor; import java.lang.reflect.Modifier; @@ -32,76 +33,78 @@ import java.util.Arrays; import java.util.List; import java.util.concurrent.CountDownLatch; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** * Unit tests {@link org.apache.commons.lang3.ThreadUtils}. */ public class ThreadUtilsTest { - @Test(expected=IllegalArgumentException.class) - public void testNullThreadName() throws InterruptedException { - ThreadUtils.findThreadsByName(null); + @Test + public void testNullThreadName() { + assertThrows(IllegalArgumentException.class, () -> ThreadUtils.findThreadsByName(null)); } - @Test(expected=IllegalArgumentException.class) - public void testNullThreadGroupName() throws InterruptedException { - ThreadUtils.findThreadGroupsByName(null); + @Test + public void testNullThreadGroupName() { + assertThrows(IllegalArgumentException.class, () -> ThreadUtils.findThreadGroupsByName(null)); } - @Test(expected=IllegalArgumentException.class) - public void testNullThreadThreadGroupName1() throws InterruptedException { - ThreadUtils.findThreadsByName(null, "tgname"); + @Test + public void testNullThreadThreadGroupName1() { + assertThrows(IllegalArgumentException.class, () -> ThreadUtils.findThreadsByName(null, "tgname")); } - @Test(expected=IllegalArgumentException.class) - public void testNullThreadThreadGroupName2() throws InterruptedException { - ThreadUtils.findThreadsByName("tname", (String) null); + @Test + public void testNullThreadThreadGroupName2() { + assertThrows(IllegalArgumentException.class, () -> ThreadUtils.findThreadsByName("tname", (String) null)); } - @Test(expected=IllegalArgumentException.class) - public void testNullThreadThreadGroupName3() throws InterruptedException { - ThreadUtils.findThreadsByName(null, (String) null); + @Test + public void testNullThreadThreadGroupName3() { + assertThrows(IllegalArgumentException.class, () -> ThreadUtils.findThreadsByName(null, (String) null)); } - @Test(expected=IllegalArgumentException.class) - public void testNullThreadThreadGroup1() throws InterruptedException { - ThreadUtils.findThreadsByName("tname", (ThreadGroup) null); + @Test + public void testNullThreadThreadGroup1() { + assertThrows(IllegalArgumentException.class, () -> ThreadUtils.findThreadsByName("tname", (ThreadGroup) null)); } - @Test(expected=IllegalArgumentException.class) - public void testNullThreadThreadGroup2() throws InterruptedException { - ThreadUtils.findThreadById(1L, (ThreadGroup) null); + @Test + public void testNullThreadThreadGroup2() { + assertThrows(IllegalArgumentException.class, () -> ThreadUtils.findThreadById(1L, (ThreadGroup) null)); } - @Test(expected=IllegalArgumentException.class) - public void testNullThreadThreadGroup3() throws InterruptedException { - ThreadUtils.findThreadsByName(null, (ThreadGroup) null); + @Test + public void testNullThreadThreadGroup3() { + assertThrows(IllegalArgumentException.class, () -> ThreadUtils.findThreadsByName(null, (ThreadGroup) null)); } - @Test(expected=IllegalArgumentException.class) - public void testInvalidThreadId() throws InterruptedException { - ThreadUtils.findThreadById(-5L); + @Test + public void testInvalidThreadId() { + assertThrows(IllegalArgumentException.class, () -> ThreadUtils.findThreadById(-5L)); } - @Test(expected=IllegalArgumentException.class) - public void testThreadGroupsByIdFail() throws InterruptedException { - ThreadUtils.findThreadById(Thread.currentThread().getId(), (String) null); + @Test + public void testThreadGroupsByIdFail() { + assertThrows(IllegalArgumentException.class, + () -> ThreadUtils.findThreadById(Thread.currentThread().getId(), (String) null)); } - @Test(expected=IllegalArgumentException.class) - public void testThreadgroupsNullParent() throws InterruptedException { - ThreadUtils.findThreadGroups(null, true, ThreadUtils.ALWAYS_TRUE_PREDICATE); + @Test + public void testThreadgroupsNullParent() { + assertThrows(IllegalArgumentException.class, + () -> ThreadUtils.findThreadGroups(null, true, ThreadUtils.ALWAYS_TRUE_PREDICATE)); } - @Test(expected=IllegalArgumentException.class) - public void testThreadgroupsNullPredicate() throws InterruptedException { - ThreadUtils.findThreadGroups(null); + @Test + public void testThreadgroupsNullPredicate() { + assertThrows(IllegalArgumentException.class, () -> ThreadUtils.findThreadGroups(null)); } - @Test(expected=IllegalArgumentException.class) - public void testThreadsNullPredicate() throws InterruptedException { - ThreadUtils.findThreads(null); + @Test + public void testThreadsNullPredicate() { + assertThrows(IllegalArgumentException.class, () -> ThreadUtils.findThreads(null)); } @Test diff --git a/src/test/java/org/apache/commons/lang3/test/SystemDefaults.java b/src/test/java/org/apache/commons/lang3/test/SystemDefaults.java deleted file mode 100644 index 0bb091254..000000000 --- a/src/test/java/org/apache/commons/lang3/test/SystemDefaults.java +++ /dev/null @@ -1,40 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.commons.lang3.test; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Annotation used with {@link SystemDefaults} that specifies the - * system default Locale and TimeZone to be used in a test method. - */ -@Target(ElementType.METHOD) -@Retention(RetentionPolicy.RUNTIME) -public @interface SystemDefaults { - /** - * The name of the Locale to be used while running a test method - */ - String locale() default ""; - /** - * The name of the TimeZone to be used while running a test method - */ - String timezone() default ""; -} diff --git a/src/test/java/org/apache/commons/lang3/test/SystemDefaultsSwitch.java b/src/test/java/org/apache/commons/lang3/test/SystemDefaultsSwitch.java deleted file mode 100644 index 091e9d8cd..000000000 --- a/src/test/java/org/apache/commons/lang3/test/SystemDefaultsSwitch.java +++ /dev/null @@ -1,113 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.commons.lang3.test; - -import java.util.Locale; -import java.util.TimeZone; - -import org.apache.commons.lang3.LocaleUtils; -import org.junit.rules.TestRule; -import org.junit.runner.Description; -import org.junit.runners.model.Statement; - -/** - * Test Rule used with {@link SystemDefaults} annotation that sets and restores the system default Locale and TimeZone. - * - *

- * Set up tests to use alternate system default Locale and/or TimeZone by creating an instance of this rule - * and annotating the test method with {@link SystemDefaults} - *

- * - * 
- * public class SystemDefaultsDependentTest {
- *
- *     {@literal @}Rule
- *     public SystemDefaultsSwitch locale = new SystemDefaultsSwitch();
- *
- *     {@literal @}Test
- *     public void testThatWillExecuteWithTheDefaultLocaleAndTimeZone() {
- *         // nothing to do, just implement the test
- *     }
- *
- *     {@literal @}Test
- *     {@literal @}SystemDefaults(locale="zh_CN")
- *     public void testWithSimplifiedChinaDefaultLocale() {
- *         // Locale.getDefault() will return Locale.CHINA until the end of this test method
- *     }
- *
- *     {@literal @}Test
- *     {@literal @}SystemDefaults(timezone="America/New_York")
- *     public void testWithNorthAmericaEasternTimeZone() {
- *         // TimeZone.getDefault() will equal TimeZone.getTimeZone("America/New_York") until the end of this method
- *     }
- * }
- *
- */ -public class SystemDefaultsSwitch implements TestRule { - - @Override - public Statement apply(final Statement stmt, final Description description) { - final SystemDefaults defaults = description.getAnnotation(SystemDefaults.class); - if (defaults == null) { - return stmt; - } - return applyTimeZone(defaults, applyLocale(defaults, stmt)); - } - - private Statement applyTimeZone(final SystemDefaults defaults, final Statement stmt) { - if (defaults.timezone().isEmpty()) { - return stmt; - } - - final TimeZone newTimeZone = TimeZone.getTimeZone(defaults.timezone()); - - return new Statement() { - @Override - public void evaluate() throws Throwable { - final TimeZone save = TimeZone.getDefault(); - try { - TimeZone.setDefault(newTimeZone); - stmt.evaluate(); - } finally { - TimeZone.setDefault(save); - } - } - }; - } - - private Statement applyLocale(final SystemDefaults defaults, final Statement stmt) { - if (defaults.locale().isEmpty()) { - return stmt; - } - - final Locale newLocale = LocaleUtils.toLocale(defaults.locale()); - - return new Statement() { - @Override - public void evaluate() throws Throwable { - final Locale save = Locale.getDefault(); - try { - Locale.setDefault(newLocale); - stmt.evaluate(); - } finally { - Locale.setDefault(save); - } - } - }; - } - -} diff --git a/src/test/java/org/apache/commons/lang3/test/SystemDefaultsSwitchTest.java b/src/test/java/org/apache/commons/lang3/test/SystemDefaultsSwitchTest.java deleted file mode 100644 index ed152bb79..000000000 --- a/src/test/java/org/apache/commons/lang3/test/SystemDefaultsSwitchTest.java +++ /dev/null @@ -1,89 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.commons.lang3.test; - -import static org.junit.Assert.assertEquals; - -import java.util.Locale; -import java.util.TimeZone; - -import org.apache.commons.lang3.time.FastTimeZone; -import org.junit.AfterClass; -import org.junit.BeforeClass; -import org.junit.Rule; -import org.junit.Test; - -public class SystemDefaultsSwitchTest { - - private static Locale TEST_DEFAULT_LOCALE; - private static Locale DEFAULT_LOCALE_BEFORE_TEST; - - private static TimeZone DEFAULT_TIMEZONE_BEFORE_TEST; - private static TimeZone TEST_DEFAULT_TIMEZONE; - - @BeforeClass - public static void classSetUp() { - DEFAULT_LOCALE_BEFORE_TEST = Locale.getDefault(); - if (!DEFAULT_LOCALE_BEFORE_TEST.equals(Locale.CANADA)) { - Locale.setDefault(Locale.CANADA); - } else { - // you seem to be from Canada... - Locale.setDefault(Locale.CHINESE); - } - TEST_DEFAULT_LOCALE = Locale.getDefault(); - - DEFAULT_TIMEZONE_BEFORE_TEST = TimeZone.getDefault(); - final TimeZone utc = FastTimeZone.getGmtTimeZone(); - if (!DEFAULT_TIMEZONE_BEFORE_TEST.equals(utc)) { - TimeZone.setDefault(utc); - } else { - TimeZone.setDefault(TimeZone.getTimeZone("GMT")); - } - TEST_DEFAULT_TIMEZONE = TimeZone.getDefault(); - } - - @Rule - public SystemDefaultsSwitch defaultsSwitch = new SystemDefaultsSwitch(); - - @Test - public void testDefaultLocaleNoAnnotation() throws Exception { - assertEquals(TEST_DEFAULT_LOCALE, Locale.getDefault()); - } - - @Test - @SystemDefaults(locale = "en_EN") - public void testUseDifferentLocale() throws Exception { - assertEquals(new Locale("en", "EN"), Locale.getDefault()); - } - - @Test - public void testDefaultTimeZoneNoAnnotation() throws Exception { - assertEquals(TEST_DEFAULT_TIMEZONE, TimeZone.getDefault()); - } - - @Test - @SystemDefaults(timezone = "CET") - public void testUseDifferentTimeZone() throws Exception { - assertEquals(TimeZone.getTimeZone("CET"), TimeZone.getDefault()); - } - - @AfterClass - public static void classTearDown() { - Locale.setDefault(DEFAULT_LOCALE_BEFORE_TEST); - TimeZone.setDefault(DEFAULT_TIMEZONE_BEFORE_TEST); - } -}