Apache/commons-lang
1
0
Fork 0
mirror of https://github.com/apache/commons-lang.git synced 2025-02-06 01:58:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update tests to JUnit Jupiter (closes #375)

Browse Source 
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.
This commit is contained in:
Allon Mureinik 2018-10-11 16:21:52 +03:00 committed by pascalschumacher
parent ca2e59c513
commit e99b0dde8e
43 changed files with 2173 additions and 2669 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
pom.xml
View File

@ -537,12 +537,6 @@
<artifactId>junit-jupiter-engine</artifactId>
<scope>test</scope>
</dependency>
<!-- Vintage engine needed for exectuing JUnit 4.x tests. Remove once all tests have been migrated to JUnit 5. -->
<dependency>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit-pioneer</groupId>
<artifactId>junit-pioneer</artifactId>

58
src/test/java/org/apache/commons/lang3/AnnotationUtilsTest.java
View File

@ -22,23 +22,26 @@
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<? extends Throwable> 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 enum Stooge {
private Field field3;
private Field field4;
@Before
@BeforeEach
public void setup() throws Exception {
field1 = getClass().getDeclaredField("dummy1");
field2 = getClass().getDeclaredField("dummy2");
@ -444,8 +458,9 @@ public void testIsValidAnnotationMemberType() {
}
}
@Test(timeout = 666000)
public void testGeneratedAnnotationEquivalentToRealAnnotation() throws Exception {
@Test
public void testGeneratedAnnotationEquivalentToRealAnnotation() {
assertTimeoutPreemptively(Duration.ofSeconds(666L), () -> {
final Test real = getClass().getDeclaredMethod(
"testGeneratedAnnotationEquivalentToRealAnnotation").getAnnotation(Test.class);
@ -467,7 +482,7 @@ public Object invoke(final Object proxy, final Method method, final Object[] arg
};
final Test generated = (Test) Proxy.newProxyInstance(Thread.currentThread()
.getContextClassLoader(), new Class[] { Test.class },
.getContextClassLoader(), new Class[]{Test.class},
generatedTestInvocationHandler);
assertTrue(real.equals(generated));
assertFalse(generated.equals(real));
@ -475,34 +490,41 @@ public Object invoke(final Object proxy, final Method method, final Object[] arg
assertTrue(AnnotationUtils.equals(real, generated));
final Test generated2 = (Test) Proxy.newProxyInstance(Thread.currentThread()
.getContextClassLoader(), new Class[] { Test.class },
.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 {
@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);
@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.junit.Test("));
assertTrue(annotationString.startsWith("@org.apache.commons.lang3.AnnotationUtilsTest$TestMethodAnnotation("));
assertTrue(annotationString.endsWith(")"));
assertTrue(annotationString.contains("expected=class org.junit.Test$None"));
assertTrue(annotationString.contains("expected=class org.apache.commons.lang3.AnnotationUtilsTest$TestMethodAnnotation$None"));
assertTrue(annotationString.contains("timeout=666000"));
assertTrue(annotationString.contains(", "));
});
}
}

14
src/test/java/org/apache/commons/lang3/ArchUtilsTest.java
View File

@ -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}.

14
src/test/java/org/apache/commons/lang3/ArrayUtilsAddTest.java
View File

@ -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.

10
src/test/java/org/apache/commons/lang3/ArrayUtilsInsertTest.java
View File

@ -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.

121
src/test/java/org/apache/commons/lang3/ArrayUtilsRemoveMultipleTest.java
View File

@ -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 void testRemoveAllObjectArrayRemoveNone() {
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 void testRemoveAllBooleanArrayRemoveNone() {
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 void testRemoveAllByteArrayRemoveNone() {
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 void testRemoveAllCharArrayRemoveNone() {
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 void testRemoveAllDoubleArrayRemoveNone() {
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 void testRemoveAllFloatArrayRemoveNone() {
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 void testRemoveAllIntArrayRemoveNone() {
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 void testRemoveAllLongArrayRemoveNone() {
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 void testRemoveAllShortArrayRemoveNone() {
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

10
src/test/java/org/apache/commons/lang3/ArrayUtilsRemoveTest.java
View File

@ -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.

1085
src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java
View File

File diff suppressed because it is too large Load Diff

8
src/test/java/org/apache/commons/lang3/BitFieldTest.java
View File

@ -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

424
src/test/java/org/apache/commons/lang3/BooleanUtilsTest.java
View File

@ -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 void test_toBoolean_int_int_int() {
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 void test_toBoolean_Integer_Integer_Integer() {
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 void test_toBooleanObject_int_int_int() {
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 void test_toBooleanObject_Integer_Integer_Integer_Integer() {
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 void test_toBooleanObject_String_String_String_String() {
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 void test_toBoolean_String_String_String() {
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,142 +440,133 @@ public void test_toString_boolean_String_String_String() {
// 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 }));
BooleanUtils.xor(new boolean[] { false, false }),
"false ^ false");
assertEquals(
"true ^ false",
true ^ false,
BooleanUtils.xor(new boolean[] { true, false }));
BooleanUtils.xor(new boolean[] { true, false }),
"true ^ false");
assertEquals(
"false ^ true",
false ^ true,
BooleanUtils.xor(new boolean[] { 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 }));
BooleanUtils.xor(new boolean[] { false, false, false }),
"false ^ false ^ false");
assertEquals(
"false ^ false ^ true",
false ^ false ^ true,
BooleanUtils.xor(new boolean[] { 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 }));
BooleanUtils.xor(new boolean[] { false, true, false }),
"false ^ true ^ false");
assertEquals(
"false ^ true ^ true",
false ^ true ^ true,
BooleanUtils.xor(new boolean[] { 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 }));
BooleanUtils.xor(new boolean[] { true, false, false }),
"true ^ false ^ false");
assertEquals(
"true ^ false ^ true",
true ^ false ^ true,
BooleanUtils.xor(new boolean[] { 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 }));
BooleanUtils.xor(new boolean[] { true, true, false }),
"true ^ true ^ false");
assertEquals(
"true ^ true ^ true",
true ^ true ^ true,
BooleanUtils.xor(new boolean[] { 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());
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());
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());
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());
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[] {
Boolean.FALSE,
Boolean.FALSE,
Boolean.FALSE })
.booleanValue());
.booleanValue(),
"false ^ false ^ false");
assertEquals(
"false ^ false ^ true",
false ^ false ^ true,
BooleanUtils
.xor(
@ -578,10 +574,10 @@ public void testXor_object_validInput_3items() {
Boolean.FALSE,
Boolean.FALSE,
Boolean.TRUE })
.booleanValue());
.booleanValue(),
"false ^ false ^ true");
assertEquals(
"false ^ true ^ false",
false ^ true ^ false,
BooleanUtils
.xor(
@ -589,10 +585,10 @@ public void testXor_object_validInput_3items() {
Boolean.FALSE,
Boolean.TRUE,
Boolean.FALSE })
.booleanValue());
.booleanValue(),
"false ^ true ^ false");
assertEquals(
"true ^ false ^ false",
true ^ false ^ false,
BooleanUtils
.xor(
@ -600,410 +596,414 @@ public void testXor_object_validInput_3items() {
Boolean.TRUE,
Boolean.FALSE,
Boolean.FALSE })
.booleanValue());
.booleanValue(),
"true ^ false ^ false");
assertEquals(
"true ^ false ^ true",
true ^ false ^ true,
BooleanUtils.xor(
new Boolean[] {
Boolean.TRUE,
Boolean.FALSE,
Boolean.TRUE })
.booleanValue());
.booleanValue(),
"true ^ false ^ true");
assertEquals(
"true ^ true ^ false",
true ^ true ^ false,
BooleanUtils.xor(
new Boolean[] {
Boolean.TRUE,
Boolean.TRUE,
Boolean.FALSE })
.booleanValue());
.booleanValue(),
"true ^ true ^ false");
assertEquals(
"false ^ true ^ true",
false ^ true ^ true,
BooleanUtils.xor(
new Boolean[] {
Boolean.FALSE,
Boolean.TRUE,
Boolean.TRUE })
.booleanValue());
.booleanValue(),
"false ^ true ^ true");
assertEquals(
"true ^ true ^ true",
true ^ true ^ true,
BooleanUtils
.xor(new Boolean[] { Boolean.TRUE, Boolean.TRUE, Boolean.TRUE })
.booleanValue());
BooleanUtils.xor(
new Boolean[] {
Boolean.TRUE,
Boolean.TRUE,
Boolean.TRUE })
.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());
.booleanValue(),
"False result for (true, true)");
assertTrue(
"True result for (false, false)",
! BooleanUtils
.and(new Boolean[] { Boolean.FALSE, Boolean.FALSE })
.booleanValue());
.booleanValue(),
"True result for (false, false)");
assertTrue(
"True result for (true, false)",
! BooleanUtils
.and(new Boolean[] { Boolean.TRUE, Boolean.FALSE })
.booleanValue());
.booleanValue(),
"True result for (true, false)");
assertTrue(
"True result for (false, true)",
! BooleanUtils
.and(new Boolean[] { Boolean.FALSE, Boolean.TRUE })
.booleanValue());
.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());
.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());
.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());
.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());
.booleanValue(),
"False result for (true, true, true)");
assertTrue(
"True result for (false, false)",
! BooleanUtils.and(
new Boolean[] {
Boolean.FALSE,
Boolean.FALSE,
Boolean.FALSE })
.booleanValue());
.booleanValue(),
"True result for (false, false)");
assertTrue(
"True result for (true, true, false)",
! BooleanUtils.and(
new Boolean[] {
Boolean.TRUE,
Boolean.TRUE,
Boolean.FALSE })
.booleanValue());
.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());
.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());
.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());
.booleanValue(),
"False result for (true, true)");
assertTrue(
"True result for (false, false)",
! BooleanUtils
.or(new Boolean[] { Boolean.FALSE, Boolean.FALSE })
.booleanValue());
.booleanValue(),
"True result for (false, false)");
assertTrue(
"False result for (true, false)",
BooleanUtils
.or(new Boolean[] { Boolean.TRUE, Boolean.FALSE })
.booleanValue());
.booleanValue(),
"False result for (true, false)");
assertTrue(
"False result for (false, true)",
BooleanUtils
.or(new Boolean[] { Boolean.FALSE, Boolean.TRUE })
.booleanValue());
.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());
.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());
.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());
.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());
.booleanValue(),
"False result for (true, true, true)");
assertTrue(
"True result for (false, false)",
! BooleanUtils.or(
new Boolean[] {
Boolean.FALSE,
Boolean.FALSE,
Boolean.FALSE })
.booleanValue());
.booleanValue(),
"True result for (false, false)");
assertTrue(
"False result for (true, true, false)",
BooleanUtils.or(
new Boolean[] {
Boolean.TRUE,
Boolean.TRUE,
Boolean.FALSE })
.booleanValue());
.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());
.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());
.booleanValue(),
"False result for (false, true, true)");
}
@Test

10
src/test/java/org/apache/commons/lang3/CharEncodingTest.java
View File

@ -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 @@
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);
}
/**

17
src/test/java/org/apache/commons/lang3/CharRangeTest.java
View File

@ -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 void testSerialization() {
}
//-----------------------------------------------------------------------
@Test(expected = UnsupportedOperationException.class)
@Test
public void testIteratorRemove() {
final CharRange a = CharRange.is('a');
final Iterator<Character> aIt = a.iterator();
aIt.remove();
assertThrows(UnsupportedOperationException.class, aIt::remove);
}
}

27
src/test/java/org/apache/commons/lang3/CharSequenceUtilsTest.java
View File

@ -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 void testSubSequence() {
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 @@ void run(final TestData data, final String id) {
}
} else {
final boolean stringCheck = invoke();
assertEquals(id + " Failed test " + data, data.expected, stringCheck);
assertEquals(data.expected, stringCheck, id + " Failed test " + data);
}
}

12
src/test/java/org/apache/commons/lang3/CharSetTest.java
View File

@ -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}.

12
src/test/java/org/apache/commons/lang3/CharSetUtilsTest.java
View File

@ -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}.

16
src/test/java/org/apache/commons/lang3/CharUtilsTest.java
View File

@ -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}.

65
src/test/java/org/apache/commons/lang3/ClassPathUtilsTest.java
View File

@ -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 void testConstructor() {
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 void testToFullyQualifiedNameClassString() throws Exception {
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 void testToFullyQualifiedNamePackageString() throws Exception {
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 void testToFullyQualifiedPathClass() throws Exception {
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

575
src/test/java/org/apache/commons/lang3/ClassUtilsTest.java
View File

@ -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.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 void test_getAbbreviatedName_Class() {
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 void test_isAssignable_ClassArray_ClassArray_NoAutoboxing() throws Except
@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 void test_isAssignable_NoAutoboxing() throws Exception {
@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 void testHierarchyIncludingInterfaces() {
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 void testPrimitivesToWrappers() {
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 void testPrimitivesToWrappers() {
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 void testToClass_object() {
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 void testWrappersToPrimitives() {
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 void testWrapperToPrimitive() {
};
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");
}
}

10
src/test/java/org/apache/commons/lang3/ConversionTest.java
View File

@ -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 @@ static String dbgPrint(final boolean[] src) {
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++ ) {

123
src/test/java/org/apache/commons/lang3/EnumUtilsTest.java
View File

@ -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.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 void testConstructable() {
@Test
public void test_getEnumMap() {
final Map<String, Traffic> 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 void test_isValidEnum() {
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 void test_isValidEnumIgnoreCase() {
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 void test_getEnum_nonEnumClass() {
assertNull(EnumUtils.getEnum(rawType, "rawType"));
}
@Test(expected=NullPointerException.class)
@Test
public void test_getEnum_nullClass() {
EnumUtils.getEnum((Class<Traffic>) null, "PURPLE");
assertThrows(NullPointerException.class, () -> EnumUtils.getEnum((Class<Traffic>) null, "PURPLE"));
}
@Test
@ -129,83 +130,89 @@ public void test_getEnumIgnoreCase_nonEnumClass() {
assertNull(EnumUtils.getEnumIgnoreCase(rawType, "rawType"));
}
@Test(expected=NullPointerException.class)
@Test
public void test_getEnumIgnoreCase_nullClass() {
EnumUtils.getEnumIgnoreCase((Class<Traffic>) null, "PURPLE");
assertThrows(NullPointerException.class, () -> EnumUtils.getEnumIgnoreCase((Class<Traffic>) 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<Traffic>) null);
assertThrows(NullPointerException.class,
() -> EnumUtils.generateBitVector(Traffic.class, (Iterable<Traffic>) null));
}
@Test(expected=NullPointerException.class)
@Test
public void test_generateBitVectors_nullIterable() {
EnumUtils.generateBitVectors(null, (Iterable<Traffic>) null);
assertThrows(NullPointerException.class, () -> EnumUtils.generateBitVectors(null, (Iterable<Traffic>) 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 void test_generateBitVector_nonEnumClass() {
@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 void test_generateBitVectors_nonEnumClass() {
@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 void test_generateBitVectorsFromArray() {
}
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<Traffic> 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<Traffic> empty = null;
EnumUtils.processBitVectors(empty, 0L);
assertThrows(NullPointerException.class, () -> EnumUtils.processBitVectors(empty, 0L));
}
@Test
@ -402,9 +409,9 @@ public void test_processBitVectors() {
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

48
src/test/java/org/apache/commons/lang3/JavaVersionTest.java
View File

@ -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

26
src/test/java/org/apache/commons/lang3/LocaleUtilsTest.java
View File

@ -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.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 void testConstructor() {
*/
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 @@ private static void assertValidToLocale(final String language) {
*/
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 @@ private static void assertValidToLocale(
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());

14
src/test/java/org/apache/commons/lang3/NotImplementedExceptionTest.java
View File

@ -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 void testConstructors() {
}
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");
}
}

134
src/test/java/org/apache/commons/lang3/ObjectUtilsTest.java
View File

@ -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 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 void testIsNotEmpty() {
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 void testAllNotNull() {
//-----------------------------------------------------------------------
@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 void testCompare() {
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 void testMedian() {
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.<String> median();
assertThrows(IllegalArgumentException.class, ObjectUtils::<String>median);
}
@Test
@ -485,19 +486,21 @@ public void testComparatorMedian() {
assertSame(blah, ObjectUtils.median(cmp, foo, bar, baz, blah, wah));
}
@Test(expected = NullPointerException.class)
@Test
public void testComparatorMedian_nullComparator() {
ObjectUtils.median((Comparator<CharSequence>) null, new NonComparableCharSequence("foo"));
assertThrows(NullPointerException.class,
() -> ObjectUtils.median((Comparator<CharSequence>) 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 void testCloneOfNotCloneable() {
/**
* 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 void testPossibleCloneOfNotCloneable() {
/**
* 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 void testConstMethods() {
// 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 void testConstMethods() {
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 {

110
src/test/java/org/apache/commons/lang3/RandomStringUtilsTest.java
View File

@ -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 void testConstructor() {
@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 void testLANG807() {
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 void testRandomAsciiRange() {
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 void testRandomAlphabeticRange() {
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 void testRandomAlphanumericRange() {
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 void testRandomGraphRange() {
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 void testRandomNumericRange() {
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 void testRandomPrintRange() {
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 void testRandomStringUtilsHomog() {
}
}
// 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 void testLang100() {
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 int nextInt(final int n) {
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));
}
}

67
src/test/java/org/apache/commons/lang3/RandomUtilsTest.java
View File

@ -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 void testConstructor() {
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));
}
/**

79
src/test/java/org/apache/commons/lang3/RangeTest.java
View File

@ -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;
/**
* <p>
@ -47,7 +48,7 @@ public class RangeTest {
private Range<Double> 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 int compare(final Integer o1, final Integer o2) {
}
};
Range<Integer> 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 int compare(final String str1, final String str2) {
}
};
Range<Integer> 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<String> 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 void testIntersectionWith() {
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)));
}
// -----------------------------------------------------------------------

8
src/test/java/org/apache/commons/lang3/RegExUtilsTest.java
View File

@ -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.

82
src/test/java/org/apache/commons/lang3/SerializationUtilsTest.java
View File

@ -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.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<Object, Object> iMap;
@Before
@BeforeEach
public void setUp() {
iString = "foo";
iInteger = Integer.valueOf(7);
@ -114,11 +115,11 @@ public void testSerializeStream() throws Exception {
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 void testSerializeStreamNullObj() throws Exception {
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 void testDeserializeStream() throws Exception {
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));
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 void testDeserializeStreamOfNull() throws Exception {
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 void testSerializeBytes() throws Exception {
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 void testDeserializeBytesOfNull() throws Exception {
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 void testCloneNull() throws Exception {
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

147
src/test/java/org/apache/commons/lang3/StringEscapeUtilsTest.java
View File

@ -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 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 @@ private void assertEscapeJava(final String escaped, final String original) throw
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 @@ private void assertUnescapeJava(final String message, final String unescaped, fi
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 void testEscapeHtml() {
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 void testUnescapeHtml4() {
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 void testUnescapeHtml4() {
} 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 void testUnescapeHtml4() {
@Test
public void testUnescapeHexCharsHtml() {
// Simple easy to grok test
assertEquals("hex number unescape", "\u0080\u009F", StringEscapeUtils.unescapeHtml4("&#x80;&#x9F;"));
assertEquals("hex number unescape", "\u0080\u009F", StringEscapeUtils.unescapeHtml4("&#X80;&#X9F;"));
assertEquals("\u0080\u009F", StringEscapeUtils.unescapeHtml4("&#x80;&#x9F;"), "hex number unescape");
assertEquals("\u0080\u009F", StringEscapeUtils.unescapeHtml4("&#X80;&#X9F;"), "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 void testUnescapeHexCharsHtml() {
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 void testEscapeXml() throws Exception {
assertEquals("&lt;abc&gt;", StringEscapeUtils.escapeXml("<abc>"));
assertEquals("<abc>", StringEscapeUtils.unescapeXml("&lt;abc&gt;"));
assertEquals("XML should not escape >0x7f values",
"\u00A1", StringEscapeUtils.escapeXml("\u00A1"));
assertEquals("XML should be able to unescape >0x7f values",
"\u00A0", StringEscapeUtils.unescapeXml("&#160;"));
assertEquals("XML should be able to unescape >0x7f values with one leading 0",
"\u00A0", StringEscapeUtils.unescapeXml("&#0160;"));
assertEquals("XML should be able to unescape >0x7f values with two leading 0s",
"\u00A0", StringEscapeUtils.unescapeXml("&#00160;"));
assertEquals("XML should be able to unescape >0x7f values with three leading 0s",
"\u00A0", StringEscapeUtils.unescapeXml("&#000160;"));
assertEquals("\u00A1", StringEscapeUtils.escapeXml("\u00A1"), "XML should not escape >0x7f values");
assertEquals("\u00A0", StringEscapeUtils.unescapeXml("&#160;"), "XML should be able to unescape >0x7f values");
assertEquals("\u00A0", StringEscapeUtils.unescapeXml("&#0160;"),
"XML should be able to unescape >0x7f values with one leading 0");
assertEquals("\u00A0", StringEscapeUtils.unescapeXml("&#00160;"),
"XML should be able to unescape >0x7f values with two leading 0s");
assertEquals("\u00A0", StringEscapeUtils.unescapeXml("&#000160;"),
"XML should be able to unescape >0x7f values with three leading 0s");
assertEquals("ain't", StringEscapeUtils.unescapeXml("ain&apos;t"));
assertEquals("ain&apos;t", StringEscapeUtils.escapeXml("ain't"));
@ -342,46 +341,46 @@ public void testEscapeXml() throws Exception {
StringEscapeUtils.ESCAPE_XML.translate("<abc>", sw);
} catch (final IOException e) {
}
assertEquals("XML was escaped incorrectly", "&lt;abc&gt;", sw.toString() );
assertEquals("&lt;abc&gt;", sw.toString(), "XML was escaped incorrectly");
sw = new StringWriter();
try {
StringEscapeUtils.UNESCAPE_XML.translate("&lt;abc&gt;", sw);
} catch (final IOException e) {
}
assertEquals("XML was unescaped incorrectly", "<abc>", sw.toString() );
assertEquals("<abc>", sw.toString(), "XML was unescaped incorrectly");
}
@Test
public void testEscapeXml10() throws Exception {
assertEquals("a&lt;b&gt;c&quot;d&apos;e&amp;f", StringEscapeUtils.escapeXml10("a<b>c\"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&#127;&#132;\u0085&#134;&#159;\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&#127;&#132;\u0085&#134;&#159;\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&lt;b&gt;c&quot;d&apos;e&amp;f", StringEscapeUtils.escapeXml11("a<b>c\"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&#1;&#8;&#11;&#12;&#14;&#31;b", StringEscapeUtils.escapeXml11("a\u0001\u0008\u000b\u000c\u000e\u001fb"));
assertEquals("XML 1.1 should escape #x7F-#x84 | #x86-#x9F",
"a\u007e&#127;&#132;\u0085&#134;&#159;\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&#1;&#8;&#11;&#12;&#14;&#31;b",
StringEscapeUtils.escapeXml11("a\u0001\u0008\u000b\u000c\u000e\u001fb"),
"XML 1.1 should escape #x1-x8 | #xb | #xc | #xe-#x19");
assertEquals("a\u007e&#127;&#132;\u0085&#134;&#159;\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 void testEscapeXmlSupplementaryCharacters() {
final CharSequenceTranslator escapeXml =
StringEscapeUtils.ESCAPE_XML.with( NumericEntityEscaper.between(0x7f, Integer.MAX_VALUE) );
assertEquals("Supplementary character must be represented using a single escape", "&#144308;",
escapeXml.translate("\uD84C\uDFB4"));
assertEquals("&#144308;", 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 &#144308;",
escapeXml.translate("a b c \uD84C\uDFB4"));
assertEquals("a b c &#144308;", escapeXml.translate("a b c \uD84C\uDFB4"),
"Supplementary characters mixed with basic characters should be encoded correctly");
}
@Test
@ -436,11 +435,11 @@ public void testEscapeXmlAllCharacters() {
*/
@Test
public void testUnescapeXmlSupplementaryCharacters() {
assertEquals("Supplementary character must be represented using a single escape", "\uD84C\uDFB4",
StringEscapeUtils.unescapeXml("&#144308;") );
assertEquals("\uD84C\uDFB4", StringEscapeUtils.unescapeXml("&#144308;"),
"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 &#144308;") );
assertEquals("a b c \uD84C\uDFB4", StringEscapeUtils.unescapeXml("a b c &#144308;"),
"Supplementary characters mixed with basic characters should be decoded correctly");
}
// Tests issue #38569
@ -492,10 +491,10 @@ private void checkCsvEscapeWriter(final String expected, final String value) {
}
}
@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 @@ private void checkCsvUnescapeWriter(final String expected, final String value) {
}
}
@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 void testEscapeHtmlHighUnicode() {
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( "&#119650;" );
@ -574,12 +573,12 @@ public void testEscapeHiragana() {
// 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 void testLang708() throws IOException {
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);
}
/**

26
src/test/java/org/apache/commons/lang3/StringUtilsContainsTest.java
View File

@ -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 void testContainsAny_StringStringArray() {
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 void testContainsIgnoreCase_LocaleIndependence() {
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]);
}
}
}

10
src/test/java/org/apache/commons/lang3/StringUtilsEmptyBlankTest.java
View File

@ -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

16
src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java
View File

@ -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

6
src/test/java/org/apache/commons/lang3/StringUtilsIsTest.java
View File

@ -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

156
src/test/java/org/apache/commons/lang3/StringUtilsStartsEndsWithTest.java
View File

@ -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 void testStartsWith() {
*/
@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 void testStartsWithAny() {
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 void testStartsWithAny() {
*/
@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 void testEndsWith() {
*/
@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 void testEndsWithIgnoreCase() {
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 void testEndsWithAny() {
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))");
}

8
src/test/java/org/apache/commons/lang3/StringUtilsSubstringTest.java
View File

@ -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

513
src/test/java/org/apache/commons/lang3/StringUtilsTest.java
View File

@ -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.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 void testConstructor() {
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 void testCapitalize() {
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 void testUnCapitalize() {
@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 void testJoinWith() {
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 @@ private void innerTestSplit(final char separator, final String sepStr, final cha
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 @@ private void innerTestSplitPreserveAllTokens(final char separator, final String
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 void testChop() {
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 void testChomp() {
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 @@ private void assertAbbreviateWithOffset(final String expected, final int offset,
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 @@ private void assertAbbreviateWithAbbrevMarkerAndOffset(final String expected, fi
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 void testGetLevenshteinDistance_StringString() {
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 void testGetLevenshteinDistance_StringStringInt() {
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 void testGetFuzzyDistance() throws Exception {
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 void testRemoveStart() {
@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 void testRemoveEnd() {
@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 void testUnescapeSurrogatePairs() throws Exception {
*/
@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 void testAppendIfMissing() {
*/
@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 void testAppendIfMissingIgnoreCase() {
*/
@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 void testPrependIfMissing() {
*/
@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)");
}
/**

24
src/test/java/org/apache/commons/lang3/StringUtilsTrimStripTest.java
View File

@ -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 void testStripAll() {
@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"));
}

14
src/test/java/org/apache/commons/lang3/SystemUtilsTest.java
View File

@ -30,18 +30,18 @@
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 void testConstructor() {
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);
}

95
src/test/java/org/apache/commons/lang3/ThreadUtilsTest.java
View File

@ -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.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

40
src/test/java/org/apache/commons/lang3/test/SystemDefaults.java
View File

@ -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 "";
}

113
src/test/java/org/apache/commons/lang3/test/SystemDefaultsSwitch.java
View File

@ -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.
*
* <p>
* 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}
* </p>
*
* <pre>
* 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
* }
* }
* </pre>
*/
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);
}
}
};
}
}

89
src/test/java/org/apache/commons/lang3/test/SystemDefaultsSwitchTest.java
View File

@ -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);
}
}