You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by se...@apache.org on 2012/09/19 03:08:05 UTC
svn commit: r1387423 [1/2] - in
/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3: ./
event/ exception/ mutable/
Author: sebb
Date: Wed Sep 19 01:08:04 2012
New Revision: 1387423
URL: http://svn.apache.org/viewvc?rev=1387423&view=rev
Log:
Simplify boolean tests and avoid boxing
Modified:
commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java
commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/BitFieldTest.java
commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/CharRangeTest.java
commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/CharSequenceUtilsTest.java
commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/CharSetTest.java
commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/CharSetUtilsTest.java
commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/ClassUtilsTest.java
commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/LocaleUtilsTest.java
commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/ObjectUtilsTest.java
commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/RandomStringUtilsTest.java
commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/SerializationUtilsTest.java
commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/event/EventUtilsTest.java
commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/exception/ContextedRuntimeExceptionTest.java
commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/exception/DefaultExceptionContextTest.java
commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableBooleanTest.java
Modified: commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java?rev=1387423&r1=1387422&r2=1387423&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java (original)
+++ commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java Wed Sep 19 01:08:04 2012
@@ -47,9 +47,9 @@ public class ArrayUtilsTest {
assertNotNull(new ArrayUtils());
Constructor<?>[] cons = ArrayUtils.class.getDeclaredConstructors();
assertEquals(1, cons.length);
- assertEquals(true, Modifier.isPublic(cons[0].getModifiers()));
- assertEquals(true, Modifier.isPublic(ArrayUtils.class.getModifiers()));
- assertEquals(false, Modifier.isFinal(ArrayUtils.class.getModifiers()));
+ assertTrue(Modifier.isPublic(cons[0].getModifiers()));
+ assertTrue(Modifier.isPublic(ArrayUtils.class.getModifiers()));
+ assertFalse(Modifier.isFinal(ArrayUtils.class.getModifiers()));
}
//-----------------------------------------------------------------------
@@ -88,15 +88,15 @@ public class ArrayUtilsTest {
//-----------------------------------------------------------------------
private void assertIsEquals(Object array1, Object array2, Object array3) {
- assertEquals(true, ArrayUtils.isEquals(array1, array1));
- assertEquals(true, ArrayUtils.isEquals(array2, array2));
- assertEquals(true, ArrayUtils.isEquals(array3, array3));
- assertEquals(false, ArrayUtils.isEquals(array1, array2));
- assertEquals(false, ArrayUtils.isEquals(array2, array1));
- assertEquals(false, ArrayUtils.isEquals(array1, array3));
- assertEquals(false, ArrayUtils.isEquals(array3, array1));
- assertEquals(false, ArrayUtils.isEquals(array1, array2));
- assertEquals(false, ArrayUtils.isEquals(array2, array1));
+ assertTrue(ArrayUtils.isEquals(array1, array1));
+ assertTrue(ArrayUtils.isEquals(array2, array2));
+ assertTrue(ArrayUtils.isEquals(array3, array3));
+ assertFalse(ArrayUtils.isEquals(array1, array2));
+ assertFalse(ArrayUtils.isEquals(array2, array1));
+ assertFalse(ArrayUtils.isEquals(array1, array3));
+ assertFalse(ArrayUtils.isEquals(array3, array1));
+ assertFalse(ArrayUtils.isEquals(array1, array2));
+ assertFalse(ArrayUtils.isEquals(array2, array1));
}
@Test
@@ -143,11 +143,11 @@ public class ArrayUtilsTest {
Object[] array3 = new Object[]{new String(new char[]{'A', 'B'})};
Object[] array4 = new Object[]{"AB"};
- assertEquals(true, ArrayUtils.isEquals(array3, array3));
- assertEquals(true, ArrayUtils.isEquals(array3, array4));
+ assertTrue(ArrayUtils.isEquals(array3, array3));
+ assertTrue(ArrayUtils.isEquals(array3, array4));
- assertEquals(true, ArrayUtils.isEquals(null, null));
- assertEquals(false, ArrayUtils.isEquals(null, array4));
+ assertTrue(ArrayUtils.isEquals(null, null));
+ assertFalse(ArrayUtils.isEquals(null, array4));
}
//-----------------------------------------------------------------------
@@ -1296,25 +1296,25 @@ public class ArrayUtilsTest {
Object[] oneArray = new Object[] {"pick"};
Object[] twoArray = new Object[] {"pick", "stick"};
- assertEquals(true, ArrayUtils.isSameLength(nullArray, nullArray));
- assertEquals(true, ArrayUtils.isSameLength(nullArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(nullArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(nullArray, twoArray));
-
- assertEquals(true, ArrayUtils.isSameLength(emptyArray, nullArray));
- assertEquals(true, ArrayUtils.isSameLength(emptyArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(emptyArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(emptyArray, twoArray));
-
- assertEquals(false, ArrayUtils.isSameLength(oneArray, nullArray));
- assertEquals(false, ArrayUtils.isSameLength(oneArray, emptyArray));
- assertEquals(true, ArrayUtils.isSameLength(oneArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(oneArray, twoArray));
-
- assertEquals(false, ArrayUtils.isSameLength(twoArray, nullArray));
- assertEquals(false, ArrayUtils.isSameLength(twoArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(twoArray, oneArray));
- assertEquals(true, ArrayUtils.isSameLength(twoArray, twoArray));
+ assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
+ assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
+
+ assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
+ assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
+
+ assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
+ assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
+ assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
+
+ assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
+ assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
+ assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
}
@Test
@@ -1324,25 +1324,25 @@ public class ArrayUtilsTest {
boolean[] oneArray = new boolean[] {true};
boolean[] twoArray = new boolean[] {true, false};
- assertEquals(true, ArrayUtils.isSameLength(nullArray, nullArray));
- assertEquals(true, ArrayUtils.isSameLength(nullArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(nullArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(nullArray, twoArray));
-
- assertEquals(true, ArrayUtils.isSameLength(emptyArray, nullArray));
- assertEquals(true, ArrayUtils.isSameLength(emptyArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(emptyArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(emptyArray, twoArray));
-
- assertEquals(false, ArrayUtils.isSameLength(oneArray, nullArray));
- assertEquals(false, ArrayUtils.isSameLength(oneArray, emptyArray));
- assertEquals(true, ArrayUtils.isSameLength(oneArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(oneArray, twoArray));
-
- assertEquals(false, ArrayUtils.isSameLength(twoArray, nullArray));
- assertEquals(false, ArrayUtils.isSameLength(twoArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(twoArray, oneArray));
- assertEquals(true, ArrayUtils.isSameLength(twoArray, twoArray));
+ assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
+ assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
+
+ assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
+ assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
+
+ assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
+ assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
+ assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
+
+ assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
+ assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
+ assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
}
@Test
@@ -1352,25 +1352,25 @@ public class ArrayUtilsTest {
long[] oneArray = new long[] {0L};
long[] twoArray = new long[] {0L, 76L};
- assertEquals(true, ArrayUtils.isSameLength(nullArray, nullArray));
- assertEquals(true, ArrayUtils.isSameLength(nullArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(nullArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(nullArray, twoArray));
-
- assertEquals(true, ArrayUtils.isSameLength(emptyArray, nullArray));
- assertEquals(true, ArrayUtils.isSameLength(emptyArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(emptyArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(emptyArray, twoArray));
-
- assertEquals(false, ArrayUtils.isSameLength(oneArray, nullArray));
- assertEquals(false, ArrayUtils.isSameLength(oneArray, emptyArray));
- assertEquals(true, ArrayUtils.isSameLength(oneArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(oneArray, twoArray));
-
- assertEquals(false, ArrayUtils.isSameLength(twoArray, nullArray));
- assertEquals(false, ArrayUtils.isSameLength(twoArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(twoArray, oneArray));
- assertEquals(true, ArrayUtils.isSameLength(twoArray, twoArray));
+ assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
+ assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
+
+ assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
+ assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
+
+ assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
+ assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
+ assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
+
+ assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
+ assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
+ assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
}
@Test
@@ -1380,25 +1380,25 @@ public class ArrayUtilsTest {
int[] oneArray = new int[] {4};
int[] twoArray = new int[] {5, 7};
- assertEquals(true, ArrayUtils.isSameLength(nullArray, nullArray));
- assertEquals(true, ArrayUtils.isSameLength(nullArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(nullArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(nullArray, twoArray));
-
- assertEquals(true, ArrayUtils.isSameLength(emptyArray, nullArray));
- assertEquals(true, ArrayUtils.isSameLength(emptyArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(emptyArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(emptyArray, twoArray));
-
- assertEquals(false, ArrayUtils.isSameLength(oneArray, nullArray));
- assertEquals(false, ArrayUtils.isSameLength(oneArray, emptyArray));
- assertEquals(true, ArrayUtils.isSameLength(oneArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(oneArray, twoArray));
-
- assertEquals(false, ArrayUtils.isSameLength(twoArray, nullArray));
- assertEquals(false, ArrayUtils.isSameLength(twoArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(twoArray, oneArray));
- assertEquals(true, ArrayUtils.isSameLength(twoArray, twoArray));
+ assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
+ assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
+
+ assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
+ assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
+
+ assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
+ assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
+ assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
+
+ assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
+ assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
+ assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
}
@Test
@@ -1408,25 +1408,25 @@ public class ArrayUtilsTest {
short[] oneArray = new short[] {4};
short[] twoArray = new short[] {6, 8};
- assertEquals(true, ArrayUtils.isSameLength(nullArray, nullArray));
- assertEquals(true, ArrayUtils.isSameLength(nullArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(nullArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(nullArray, twoArray));
-
- assertEquals(true, ArrayUtils.isSameLength(emptyArray, nullArray));
- assertEquals(true, ArrayUtils.isSameLength(emptyArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(emptyArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(emptyArray, twoArray));
-
- assertEquals(false, ArrayUtils.isSameLength(oneArray, nullArray));
- assertEquals(false, ArrayUtils.isSameLength(oneArray, emptyArray));
- assertEquals(true, ArrayUtils.isSameLength(oneArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(oneArray, twoArray));
-
- assertEquals(false, ArrayUtils.isSameLength(twoArray, nullArray));
- assertEquals(false, ArrayUtils.isSameLength(twoArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(twoArray, oneArray));
- assertEquals(true, ArrayUtils.isSameLength(twoArray, twoArray));
+ assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
+ assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
+
+ assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
+ assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
+
+ assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
+ assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
+ assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
+
+ assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
+ assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
+ assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
}
@Test
@@ -1436,25 +1436,25 @@ public class ArrayUtilsTest {
char[] oneArray = new char[] {'f'};
char[] twoArray = new char[] {'d', 't'};
- assertEquals(true, ArrayUtils.isSameLength(nullArray, nullArray));
- assertEquals(true, ArrayUtils.isSameLength(nullArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(nullArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(nullArray, twoArray));
-
- assertEquals(true, ArrayUtils.isSameLength(emptyArray, nullArray));
- assertEquals(true, ArrayUtils.isSameLength(emptyArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(emptyArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(emptyArray, twoArray));
-
- assertEquals(false, ArrayUtils.isSameLength(oneArray, nullArray));
- assertEquals(false, ArrayUtils.isSameLength(oneArray, emptyArray));
- assertEquals(true, ArrayUtils.isSameLength(oneArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(oneArray, twoArray));
-
- assertEquals(false, ArrayUtils.isSameLength(twoArray, nullArray));
- assertEquals(false, ArrayUtils.isSameLength(twoArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(twoArray, oneArray));
- assertEquals(true, ArrayUtils.isSameLength(twoArray, twoArray));
+ assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
+ assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
+
+ assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
+ assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
+
+ assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
+ assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
+ assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
+
+ assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
+ assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
+ assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
}
@Test
@@ -1464,25 +1464,25 @@ public class ArrayUtilsTest {
byte[] oneArray = new byte[] {3};
byte[] twoArray = new byte[] {4, 6};
- assertEquals(true, ArrayUtils.isSameLength(nullArray, nullArray));
- assertEquals(true, ArrayUtils.isSameLength(nullArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(nullArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(nullArray, twoArray));
-
- assertEquals(true, ArrayUtils.isSameLength(emptyArray, nullArray));
- assertEquals(true, ArrayUtils.isSameLength(emptyArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(emptyArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(emptyArray, twoArray));
-
- assertEquals(false, ArrayUtils.isSameLength(oneArray, nullArray));
- assertEquals(false, ArrayUtils.isSameLength(oneArray, emptyArray));
- assertEquals(true, ArrayUtils.isSameLength(oneArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(oneArray, twoArray));
-
- assertEquals(false, ArrayUtils.isSameLength(twoArray, nullArray));
- assertEquals(false, ArrayUtils.isSameLength(twoArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(twoArray, oneArray));
- assertEquals(true, ArrayUtils.isSameLength(twoArray, twoArray));
+ assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
+ assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
+
+ assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
+ assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
+
+ assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
+ assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
+ assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
+
+ assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
+ assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
+ assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
}
@Test
@@ -1492,25 +1492,25 @@ public class ArrayUtilsTest {
double[] oneArray = new double[] {1.3d};
double[] twoArray = new double[] {4.5d, 6.3d};
- assertEquals(true, ArrayUtils.isSameLength(nullArray, nullArray));
- assertEquals(true, ArrayUtils.isSameLength(nullArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(nullArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(nullArray, twoArray));
-
- assertEquals(true, ArrayUtils.isSameLength(emptyArray, nullArray));
- assertEquals(true, ArrayUtils.isSameLength(emptyArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(emptyArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(emptyArray, twoArray));
-
- assertEquals(false, ArrayUtils.isSameLength(oneArray, nullArray));
- assertEquals(false, ArrayUtils.isSameLength(oneArray, emptyArray));
- assertEquals(true, ArrayUtils.isSameLength(oneArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(oneArray, twoArray));
-
- assertEquals(false, ArrayUtils.isSameLength(twoArray, nullArray));
- assertEquals(false, ArrayUtils.isSameLength(twoArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(twoArray, oneArray));
- assertEquals(true, ArrayUtils.isSameLength(twoArray, twoArray));
+ assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
+ assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
+
+ assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
+ assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
+
+ assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
+ assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
+ assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
+
+ assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
+ assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
+ assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
}
@Test
@@ -1520,25 +1520,25 @@ public class ArrayUtilsTest {
float[] oneArray = new float[] {2.5f};
float[] twoArray = new float[] {6.4f, 5.8f};
- assertEquals(true, ArrayUtils.isSameLength(nullArray, nullArray));
- assertEquals(true, ArrayUtils.isSameLength(nullArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(nullArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(nullArray, twoArray));
-
- assertEquals(true, ArrayUtils.isSameLength(emptyArray, nullArray));
- assertEquals(true, ArrayUtils.isSameLength(emptyArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(emptyArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(emptyArray, twoArray));
-
- assertEquals(false, ArrayUtils.isSameLength(oneArray, nullArray));
- assertEquals(false, ArrayUtils.isSameLength(oneArray, emptyArray));
- assertEquals(true, ArrayUtils.isSameLength(oneArray, oneArray));
- assertEquals(false, ArrayUtils.isSameLength(oneArray, twoArray));
-
- assertEquals(false, ArrayUtils.isSameLength(twoArray, nullArray));
- assertEquals(false, ArrayUtils.isSameLength(twoArray, emptyArray));
- assertEquals(false, ArrayUtils.isSameLength(twoArray, oneArray));
- assertEquals(true, ArrayUtils.isSameLength(twoArray, twoArray));
+ assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
+ assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
+
+ assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
+ assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
+
+ assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
+ assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
+ assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
+ assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
+
+ assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
+ assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
+ assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
+ assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
}
//-----------------------------------------------------------------------
@@ -1557,11 +1557,11 @@ public class ArrayUtilsTest {
fail();
} catch (IllegalArgumentException ex) {}
- assertEquals(true, ArrayUtils.isSameType(new Object[0], new Object[0]));
- assertEquals(false, ArrayUtils.isSameType(new String[0], new Object[0]));
- assertEquals(true, ArrayUtils.isSameType(new String[0][0], new String[0][0]));
- assertEquals(false, ArrayUtils.isSameType(new String[0], new String[0][0]));
- assertEquals(false, ArrayUtils.isSameType(new String[0][0], new String[0]));
+ assertTrue(ArrayUtils.isSameType(new Object[0], new Object[0]));
+ assertFalse(ArrayUtils.isSameType(new String[0], new Object[0]));
+ assertTrue(ArrayUtils.isSameType(new String[0][0], new String[0][0]));
+ assertFalse(ArrayUtils.isSameType(new String[0], new String[0][0]));
+ assertFalse(ArrayUtils.isSameType(new String[0][0], new String[0]));
}
//-----------------------------------------------------------------------
@@ -1685,9 +1685,9 @@ public class ArrayUtilsTest {
public void testReverseBoolean() {
boolean[] array = new boolean[] {false, false, true};
ArrayUtils.reverse(array);
- assertEquals(array[0], true);
- assertEquals(array[1], false);
- assertEquals(array[2], false);
+ assertTrue(array[0]);
+ assertFalse(array[1]);
+ assertFalse(array[2]);
array = null;
ArrayUtils.reverse(array);
@@ -1761,14 +1761,14 @@ public class ArrayUtilsTest {
@Test
public void testContains() {
Object[] array = new Object[] { "0", "1", "2", "3", null, "0" };
- assertEquals(false, ArrayUtils.contains(null, null));
- assertEquals(false, ArrayUtils.contains(null, "1"));
- assertEquals(true, ArrayUtils.contains(array, "0"));
- assertEquals(true, ArrayUtils.contains(array, "1"));
- assertEquals(true, ArrayUtils.contains(array, "2"));
- assertEquals(true, ArrayUtils.contains(array, "3"));
- assertEquals(true, ArrayUtils.contains(array, null));
- assertEquals(false, ArrayUtils.contains(array, "notInArray"));
+ assertFalse(ArrayUtils.contains(null, null));
+ assertFalse(ArrayUtils.contains(null, "1"));
+ assertTrue(ArrayUtils.contains(array, "0"));
+ assertTrue(ArrayUtils.contains(array, "1"));
+ assertTrue(ArrayUtils.contains(array, "2"));
+ assertTrue(ArrayUtils.contains(array, "3"));
+ assertTrue(ArrayUtils.contains(array, null));
+ assertFalse(ArrayUtils.contains(array, "notInArray"));
}
//-----------------------------------------------------------------------
@@ -1827,13 +1827,13 @@ public class ArrayUtilsTest {
@Test
public void testContainsLong() {
long[] array = null;
- assertEquals(false, ArrayUtils.contains(array, 1));
+ assertFalse(ArrayUtils.contains(array, 1));
array = new long[] { 0, 1, 2, 3, 0 };
- assertEquals(true, ArrayUtils.contains(array, 0));
- assertEquals(true, ArrayUtils.contains(array, 1));
- assertEquals(true, ArrayUtils.contains(array, 2));
- assertEquals(true, ArrayUtils.contains(array, 3));
- assertEquals(false, ArrayUtils.contains(array, 99));
+ assertTrue(ArrayUtils.contains(array, 0));
+ assertTrue(ArrayUtils.contains(array, 1));
+ assertTrue(ArrayUtils.contains(array, 2));
+ assertTrue(ArrayUtils.contains(array, 3));
+ assertFalse(ArrayUtils.contains(array, 99));
}
//-----------------------------------------------------------------------
@@ -1892,13 +1892,13 @@ public class ArrayUtilsTest {
@Test
public void testContainsInt() {
int[] array = null;
- assertEquals(false, ArrayUtils.contains(array, 1));
+ assertFalse(ArrayUtils.contains(array, 1));
array = new int[] { 0, 1, 2, 3, 0 };
- assertEquals(true, ArrayUtils.contains(array, 0));
- assertEquals(true, ArrayUtils.contains(array, 1));
- assertEquals(true, ArrayUtils.contains(array, 2));
- assertEquals(true, ArrayUtils.contains(array, 3));
- assertEquals(false, ArrayUtils.contains(array, 99));
+ assertTrue(ArrayUtils.contains(array, 0));
+ assertTrue(ArrayUtils.contains(array, 1));
+ assertTrue(ArrayUtils.contains(array, 2));
+ assertTrue(ArrayUtils.contains(array, 3));
+ assertFalse(ArrayUtils.contains(array, 99));
}
//-----------------------------------------------------------------------
@@ -1957,13 +1957,13 @@ public class ArrayUtilsTest {
@Test
public void testContainsShort() {
short[] array = null;
- assertEquals(false, ArrayUtils.contains(array, (short) 1));
+ assertFalse(ArrayUtils.contains(array, (short) 1));
array = new short[] { 0, 1, 2, 3, 0 };
- assertEquals(true, ArrayUtils.contains(array, (short) 0));
- assertEquals(true, ArrayUtils.contains(array, (short) 1));
- assertEquals(true, ArrayUtils.contains(array, (short) 2));
- assertEquals(true, ArrayUtils.contains(array, (short) 3));
- assertEquals(false, ArrayUtils.contains(array, (short) 99));
+ assertTrue(ArrayUtils.contains(array, (short) 0));
+ assertTrue(ArrayUtils.contains(array, (short) 1));
+ assertTrue(ArrayUtils.contains(array, (short) 2));
+ assertTrue(ArrayUtils.contains(array, (short) 3));
+ assertFalse(ArrayUtils.contains(array, (short) 99));
}
//-----------------------------------------------------------------------
@@ -2022,13 +2022,13 @@ public class ArrayUtilsTest {
@Test
public void testContainsChar() {
char[] array = null;
- assertEquals(false, ArrayUtils.contains(array, 'b'));
+ assertFalse(ArrayUtils.contains(array, 'b'));
array = new char[] { 'a', 'b', 'c', 'd', 'a' };
- assertEquals(true, ArrayUtils.contains(array, 'a'));
- assertEquals(true, ArrayUtils.contains(array, 'b'));
- assertEquals(true, ArrayUtils.contains(array, 'c'));
- assertEquals(true, ArrayUtils.contains(array, 'd'));
- assertEquals(false, ArrayUtils.contains(array, 'e'));
+ assertTrue(ArrayUtils.contains(array, 'a'));
+ assertTrue(ArrayUtils.contains(array, 'b'));
+ assertTrue(ArrayUtils.contains(array, 'c'));
+ assertTrue(ArrayUtils.contains(array, 'd'));
+ assertFalse(ArrayUtils.contains(array, 'e'));
}
//-----------------------------------------------------------------------
@@ -2087,13 +2087,13 @@ public class ArrayUtilsTest {
@Test
public void testContainsByte() {
byte[] array = null;
- assertEquals(false, ArrayUtils.contains(array, (byte) 1));
+ assertFalse(ArrayUtils.contains(array, (byte) 1));
array = new byte[] { 0, 1, 2, 3, 0 };
- assertEquals(true, ArrayUtils.contains(array, (byte) 0));
- assertEquals(true, ArrayUtils.contains(array, (byte) 1));
- assertEquals(true, ArrayUtils.contains(array, (byte) 2));
- assertEquals(true, ArrayUtils.contains(array, (byte) 3));
- assertEquals(false, ArrayUtils.contains(array, (byte) 99));
+ assertTrue(ArrayUtils.contains(array, (byte) 0));
+ assertTrue(ArrayUtils.contains(array, (byte) 1));
+ assertTrue(ArrayUtils.contains(array, (byte) 2));
+ assertTrue(ArrayUtils.contains(array, (byte) 3));
+ assertFalse(ArrayUtils.contains(array, (byte) 99));
}
//-----------------------------------------------------------------------
@@ -2229,25 +2229,25 @@ public class ArrayUtilsTest {
@Test
public void testContainsDouble() {
double[] array = null;
- assertEquals(false, ArrayUtils.contains(array, (double) 1));
+ assertFalse(ArrayUtils.contains(array, (double) 1));
array = new double[] { 0, 1, 2, 3, 0 };
- assertEquals(true, ArrayUtils.contains(array, (double) 0));
- assertEquals(true, ArrayUtils.contains(array, (double) 1));
- assertEquals(true, ArrayUtils.contains(array, (double) 2));
- assertEquals(true, ArrayUtils.contains(array, (double) 3));
- assertEquals(false, ArrayUtils.contains(array, (double) 99));
+ assertTrue(ArrayUtils.contains(array, (double) 0));
+ assertTrue(ArrayUtils.contains(array, (double) 1));
+ assertTrue(ArrayUtils.contains(array, (double) 2));
+ assertTrue(ArrayUtils.contains(array, (double) 3));
+ assertFalse(ArrayUtils.contains(array, (double) 99));
}
@SuppressWarnings("cast")
@Test
public void testContainsDoubleTolerance() {
double[] array = null;
- assertEquals(false, ArrayUtils.contains(array, (double) 1, (double) 0));
+ assertFalse(ArrayUtils.contains(array, (double) 1, (double) 0));
array = new double[] { 0, 1, 2, 3, 0 };
- assertEquals(false, ArrayUtils.contains(array, (double) 4.0, (double) 0.33));
- assertEquals(false, ArrayUtils.contains(array, (double) 2.5, (double) 0.49));
- assertEquals(true, ArrayUtils.contains(array, (double) 2.5, (double) 0.50));
- assertEquals(true, ArrayUtils.contains(array, (double) 2.5, (double) 0.51));
+ assertFalse(ArrayUtils.contains(array, (double) 4.0, (double) 0.33));
+ assertFalse(ArrayUtils.contains(array, (double) 2.5, (double) 0.49));
+ assertTrue(ArrayUtils.contains(array, (double) 2.5, (double) 0.50));
+ assertTrue(ArrayUtils.contains(array, (double) 2.5, (double) 0.51));
}
//-----------------------------------------------------------------------
@@ -2319,13 +2319,13 @@ public class ArrayUtilsTest {
@Test
public void testContainsFloat() {
float[] array = null;
- assertEquals(false, ArrayUtils.contains(array, (float) 1));
+ assertFalse(ArrayUtils.contains(array, (float) 1));
array = new float[] { 0, 1, 2, 3, 0 };
- assertEquals(true, ArrayUtils.contains(array, (float) 0));
- assertEquals(true, ArrayUtils.contains(array, (float) 1));
- assertEquals(true, ArrayUtils.contains(array, (float) 2));
- assertEquals(true, ArrayUtils.contains(array, (float) 3));
- assertEquals(false, ArrayUtils.contains(array, (float) 99));
+ assertTrue(ArrayUtils.contains(array, (float) 0));
+ assertTrue(ArrayUtils.contains(array, (float) 1));
+ assertTrue(ArrayUtils.contains(array, (float) 2));
+ assertTrue(ArrayUtils.contains(array, (float) 3));
+ assertFalse(ArrayUtils.contains(array, (float) 99));
}
//-----------------------------------------------------------------------
@@ -2390,13 +2390,13 @@ public class ArrayUtilsTest {
@Test
public void testContainsBoolean() {
boolean[] array = null;
- assertEquals(false, ArrayUtils.contains(array, true));
+ assertFalse(ArrayUtils.contains(array, true));
array = new boolean[] { true, false, true };
- assertEquals(true, ArrayUtils.contains(array, true));
- assertEquals(true, ArrayUtils.contains(array, false));
+ assertTrue(ArrayUtils.contains(array, true));
+ assertTrue(ArrayUtils.contains(array, false));
array = new boolean[] { true, true };
- assertEquals(true, ArrayUtils.contains(array, true));
- assertEquals(false, ArrayUtils.contains(array, false));
+ assertTrue(ArrayUtils.contains(array, true));
+ assertFalse(ArrayUtils.contains(array, false));
}
// testToPrimitive/Object for boolean
@@ -2874,9 +2874,9 @@ public class ArrayUtilsTest {
public void testIsEmptyObject() {
Object[] emptyArray = new Object[] {};
Object[] notEmptyArray = new Object[] { new String("Value") };
- assertEquals(true, ArrayUtils.isEmpty((Object[])null));
- assertEquals(true, ArrayUtils.isEmpty(emptyArray));
- assertEquals(false, ArrayUtils.isEmpty(notEmptyArray));
+ assertTrue(ArrayUtils.isEmpty((Object[])null));
+ assertTrue(ArrayUtils.isEmpty(emptyArray));
+ assertFalse(ArrayUtils.isEmpty(notEmptyArray));
}
/**
@@ -2893,51 +2893,51 @@ public class ArrayUtilsTest {
public void testIsEmptyPrimitives() {
long[] emptyLongArray = new long[] {};
long[] notEmptyLongArray = new long[] { 1L };
- assertEquals(true, ArrayUtils.isEmpty((long[])null));
- assertEquals(true, ArrayUtils.isEmpty(emptyLongArray));
- assertEquals(false, ArrayUtils.isEmpty(notEmptyLongArray));
+ assertTrue(ArrayUtils.isEmpty((long[])null));
+ assertTrue(ArrayUtils.isEmpty(emptyLongArray));
+ assertFalse(ArrayUtils.isEmpty(notEmptyLongArray));
int[] emptyIntArray = new int[] {};
int[] notEmptyIntArray = new int[] { 1 };
- assertEquals(true, ArrayUtils.isEmpty((int[])null));
- assertEquals(true, ArrayUtils.isEmpty(emptyIntArray));
- assertEquals(false, ArrayUtils.isEmpty(notEmptyIntArray));
+ assertTrue(ArrayUtils.isEmpty((int[])null));
+ assertTrue(ArrayUtils.isEmpty(emptyIntArray));
+ assertFalse(ArrayUtils.isEmpty(notEmptyIntArray));
short[] emptyShortArray = new short[] {};
short[] notEmptyShortArray = new short[] { 1 };
- assertEquals(true, ArrayUtils.isEmpty((short[])null));
- assertEquals(true, ArrayUtils.isEmpty(emptyShortArray));
- assertEquals(false, ArrayUtils.isEmpty(notEmptyShortArray));
+ assertTrue(ArrayUtils.isEmpty((short[])null));
+ assertTrue(ArrayUtils.isEmpty(emptyShortArray));
+ assertFalse(ArrayUtils.isEmpty(notEmptyShortArray));
char[] emptyCharArray = new char[] {};
char[] notEmptyCharArray = new char[] { 1 };
- assertEquals(true, ArrayUtils.isEmpty((char[])null));
- assertEquals(true, ArrayUtils.isEmpty(emptyCharArray));
- assertEquals(false, ArrayUtils.isEmpty(notEmptyCharArray));
+ assertTrue(ArrayUtils.isEmpty((char[])null));
+ assertTrue(ArrayUtils.isEmpty(emptyCharArray));
+ assertFalse(ArrayUtils.isEmpty(notEmptyCharArray));
byte[] emptyByteArray = new byte[] {};
byte[] notEmptyByteArray = new byte[] { 1 };
- assertEquals(true, ArrayUtils.isEmpty((byte[])null));
- assertEquals(true, ArrayUtils.isEmpty(emptyByteArray));
- assertEquals(false, ArrayUtils.isEmpty(notEmptyByteArray));
+ assertTrue(ArrayUtils.isEmpty((byte[])null));
+ assertTrue(ArrayUtils.isEmpty(emptyByteArray));
+ assertFalse(ArrayUtils.isEmpty(notEmptyByteArray));
double[] emptyDoubleArray = new double[] {};
double[] notEmptyDoubleArray = new double[] { 1.0 };
- assertEquals(true, ArrayUtils.isEmpty((double[])null));
- assertEquals(true, ArrayUtils.isEmpty(emptyDoubleArray));
- assertEquals(false, ArrayUtils.isEmpty(notEmptyDoubleArray));
+ assertTrue(ArrayUtils.isEmpty((double[])null));
+ assertTrue(ArrayUtils.isEmpty(emptyDoubleArray));
+ assertFalse(ArrayUtils.isEmpty(notEmptyDoubleArray));
float[] emptyFloatArray = new float[] {};
float[] notEmptyFloatArray = new float[] { 1.0F };
- assertEquals(true, ArrayUtils.isEmpty((float[])null));
- assertEquals(true, ArrayUtils.isEmpty(emptyFloatArray));
- assertEquals(false, ArrayUtils.isEmpty(notEmptyFloatArray));
+ assertTrue(ArrayUtils.isEmpty((float[])null));
+ assertTrue(ArrayUtils.isEmpty(emptyFloatArray));
+ assertFalse(ArrayUtils.isEmpty(notEmptyFloatArray));
boolean[] emptyBooleanArray = new boolean[] {};
boolean[] notEmptyBooleanArray = new boolean[] { true };
- assertEquals(true, ArrayUtils.isEmpty((boolean[])null));
- assertEquals(true, ArrayUtils.isEmpty(emptyBooleanArray));
- assertEquals(false, ArrayUtils.isEmpty(notEmptyBooleanArray));
+ assertTrue(ArrayUtils.isEmpty((boolean[])null));
+ assertTrue(ArrayUtils.isEmpty(emptyBooleanArray));
+ assertFalse(ArrayUtils.isEmpty(notEmptyBooleanArray));
}
/**
Modified: commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/BitFieldTest.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/BitFieldTest.java?rev=1387423&r1=1387422&r2=1387423&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/BitFieldTest.java (original)
+++ commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/BitFieldTest.java Wed Sep 19 01:08:04 2012
@@ -17,6 +17,7 @@
package org.apache.commons.lang3;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import org.junit.Test;
@@ -188,7 +189,7 @@ public class BitFieldTest {
assertEquals(-2, new BitField(1).setByteBoolean((byte) 255, false));
byte clearedBit = new BitField(0x40).setByteBoolean((byte) - 63, false);
- assertEquals(false, new BitField(0x40).isSet(clearedBit));
+ assertFalse(new BitField(0x40).isSet(clearedBit));
}
/**
Modified: commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/CharRangeTest.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/CharRangeTest.java?rev=1387423&r1=1387422&r2=1387423&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/CharRangeTest.java (original)
+++ commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/CharRangeTest.java Wed Sep 19 01:08:04 2012
@@ -41,8 +41,8 @@ public class CharRangeTest {
@Test
public void testClass() {
// class changed to non-public in 3.0
- assertEquals(false, Modifier.isPublic(CharRange.class.getModifiers()));
- assertEquals(true, Modifier.isFinal(CharRange.class.getModifiers()));
+ assertFalse(Modifier.isPublic(CharRange.class.getModifiers()));
+ assertTrue(Modifier.isFinal(CharRange.class.getModifiers()));
}
//-----------------------------------------------------------------------
@@ -51,7 +51,7 @@ public class CharRangeTest {
CharRange rangea = CharRange.is('a');
assertEquals('a', rangea.getStart());
assertEquals('a', rangea.getEnd());
- assertEquals(false, rangea.isNegated());
+ assertFalse(rangea.isNegated());
assertEquals("a", rangea.toString());
}
@@ -60,7 +60,7 @@ public class CharRangeTest {
CharRange rangea = CharRange.isNot('a');
assertEquals('a', rangea.getStart());
assertEquals('a', rangea.getEnd());
- assertEquals(true, rangea.isNegated());
+ assertTrue(rangea.isNegated());
assertEquals("^a", rangea.toString());
}
@@ -69,7 +69,7 @@ public class CharRangeTest {
CharRange rangea = CharRange.isIn('a', 'a');
assertEquals('a', rangea.getStart());
assertEquals('a', rangea.getEnd());
- assertEquals(false, rangea.isNegated());
+ assertFalse(rangea.isNegated());
assertEquals("a", rangea.toString());
}
@@ -78,7 +78,7 @@ public class CharRangeTest {
CharRange rangea = CharRange.isIn('a', 'e');
assertEquals('a', rangea.getStart());
assertEquals('e', rangea.getEnd());
- assertEquals(false, rangea.isNegated());
+ assertFalse(rangea.isNegated());
assertEquals("a-e", rangea.toString());
}
@@ -87,7 +87,7 @@ public class CharRangeTest {
CharRange rangea = CharRange.isIn('e', 'a');
assertEquals('a', rangea.getStart());
assertEquals('e', rangea.getEnd());
- assertEquals(false, rangea.isNegated());
+ assertFalse(rangea.isNegated());
assertEquals("a-e", rangea.toString());
}
@@ -96,7 +96,7 @@ public class CharRangeTest {
CharRange rangea = CharRange.isNotIn('a', 'a');
assertEquals('a', rangea.getStart());
assertEquals('a', rangea.getEnd());
- assertEquals(true, rangea.isNegated());
+ assertTrue(rangea.isNegated());
assertEquals("^a", rangea.toString());
}
@@ -105,7 +105,7 @@ public class CharRangeTest {
CharRange rangea = CharRange.isNotIn('a', 'e');
assertEquals('a', rangea.getStart());
assertEquals('e', rangea.getEnd());
- assertEquals(true, rangea.isNegated());
+ assertTrue(rangea.isNegated());
assertEquals("^a-e", rangea.toString());
}
@@ -114,7 +114,7 @@ public class CharRangeTest {
CharRange rangea = CharRange.isNotIn('e', 'a');
assertEquals('a', rangea.getStart());
assertEquals('e', rangea.getEnd());
- assertEquals(true, rangea.isNegated());
+ assertTrue(rangea.isNegated());
assertEquals("^a-e", rangea.toString());
}
@@ -125,21 +125,21 @@ public class CharRangeTest {
CharRange rangeae = CharRange.isIn('a', 'e');
CharRange rangenotbf = CharRange.isIn('b', 'f');
- assertEquals(false, rangea.equals(null));
+ assertFalse(rangea.equals(null));
- assertEquals(true, rangea.equals(rangea));
- assertEquals(true, rangea.equals(CharRange.is('a')));
- assertEquals(true, rangeae.equals(rangeae));
- assertEquals(true, rangeae.equals(CharRange.isIn('a', 'e')));
- assertEquals(true, rangenotbf.equals(rangenotbf));
- assertEquals(true, rangenotbf.equals(CharRange.isIn('b', 'f')));
-
- assertEquals(false, rangea.equals(rangeae));
- assertEquals(false, rangea.equals(rangenotbf));
- assertEquals(false, rangeae.equals(rangea));
- assertEquals(false, rangeae.equals(rangenotbf));
- assertEquals(false, rangenotbf.equals(rangea));
- assertEquals(false, rangenotbf.equals(rangeae));
+ assertTrue(rangea.equals(rangea));
+ assertTrue(rangea.equals(CharRange.is('a')));
+ assertTrue(rangeae.equals(rangeae));
+ assertTrue(rangeae.equals(CharRange.isIn('a', 'e')));
+ assertTrue(rangenotbf.equals(rangenotbf));
+ assertTrue(rangenotbf.equals(CharRange.isIn('b', 'f')));
+
+ assertFalse(rangea.equals(rangeae));
+ assertFalse(rangea.equals(rangenotbf));
+ assertFalse(rangeae.equals(rangea));
+ assertFalse(rangeae.equals(rangenotbf));
+ assertFalse(rangenotbf.equals(rangea));
+ assertFalse(rangenotbf.equals(rangeae));
}
@Test
@@ -155,42 +155,42 @@ public class CharRangeTest {
assertEquals(true, rangenotbf.hashCode() == rangenotbf.hashCode());
assertEquals(true, rangenotbf.hashCode() == CharRange.isIn('b', 'f').hashCode());
- assertEquals(false, rangea.hashCode() == rangeae.hashCode());
- assertEquals(false, rangea.hashCode() == rangenotbf.hashCode());
- assertEquals(false, rangeae.hashCode() == rangea.hashCode());
- assertEquals(false, rangeae.hashCode() == rangenotbf.hashCode());
- assertEquals(false, rangenotbf.hashCode() == rangea.hashCode());
- assertEquals(false, rangenotbf.hashCode() == rangeae.hashCode());
+ assertFalse(rangea.hashCode() == rangeae.hashCode());
+ assertFalse(rangea.hashCode() == rangenotbf.hashCode());
+ assertFalse(rangeae.hashCode() == rangea.hashCode());
+ assertFalse(rangeae.hashCode() == rangenotbf.hashCode());
+ assertFalse(rangenotbf.hashCode() == rangea.hashCode());
+ assertFalse(rangenotbf.hashCode() == rangeae.hashCode());
}
//-----------------------------------------------------------------------
@Test
public void testContains_Char() {
CharRange range = CharRange.is('c');
- assertEquals(false, range.contains('b'));
- assertEquals(true, range.contains('c'));
- assertEquals(false, range.contains('d'));
- assertEquals(false, range.contains('e'));
+ assertFalse(range.contains('b'));
+ assertTrue(range.contains('c'));
+ assertFalse(range.contains('d'));
+ assertFalse(range.contains('e'));
range = CharRange.isIn('c', 'd');
- assertEquals(false, range.contains('b'));
- assertEquals(true, range.contains('c'));
- assertEquals(true, range.contains('d'));
- assertEquals(false, range.contains('e'));
+ assertFalse(range.contains('b'));
+ assertTrue(range.contains('c'));
+ assertTrue(range.contains('d'));
+ assertFalse(range.contains('e'));
range = CharRange.isIn('d', 'c');
- assertEquals(false, range.contains('b'));
- assertEquals(true, range.contains('c'));
- assertEquals(true, range.contains('d'));
- assertEquals(false, range.contains('e'));
+ assertFalse(range.contains('b'));
+ assertTrue(range.contains('c'));
+ assertTrue(range.contains('d'));
+ assertFalse(range.contains('e'));
range = CharRange.isNotIn('c', 'd');
- assertEquals(true, range.contains('b'));
- assertEquals(false, range.contains('c'));
- assertEquals(false, range.contains('d'));
- assertEquals(true, range.contains('e'));
- assertEquals(true, range.contains((char) 0));
- assertEquals(true, range.contains(Character.MAX_VALUE));
+ assertTrue(range.contains('b'));
+ assertFalse(range.contains('c'));
+ assertFalse(range.contains('d'));
+ assertTrue(range.contains('e'));
+ assertTrue(range.contains((char) 0));
+ assertTrue(range.contains(Character.MAX_VALUE));
}
//-----------------------------------------------------------------------
@@ -211,28 +211,28 @@ public class CharRangeTest {
CharRange ae = CharRange.isIn('a', 'e');
// normal/normal
- assertEquals(false, c.contains(b));
- assertEquals(true, c.contains(c));
- assertEquals(true, c.contains(c2));
- assertEquals(false, c.contains(d));
-
- assertEquals(false, c.contains(cd));
- assertEquals(false, c.contains(bd));
- assertEquals(false, c.contains(bc));
- assertEquals(false, c.contains(ab));
- assertEquals(false, c.contains(de));
-
- assertEquals(true, cd.contains(c));
- assertEquals(true, bd.contains(c));
- assertEquals(true, bc.contains(c));
- assertEquals(false, ab.contains(c));
- assertEquals(false, de.contains(c));
-
- assertEquals(true, ae.contains(b));
- assertEquals(true, ae.contains(ab));
- assertEquals(true, ae.contains(bc));
- assertEquals(true, ae.contains(cd));
- assertEquals(true, ae.contains(de));
+ assertFalse(c.contains(b));
+ assertTrue(c.contains(c));
+ assertTrue(c.contains(c2));
+ assertFalse(c.contains(d));
+
+ assertFalse(c.contains(cd));
+ assertFalse(c.contains(bd));
+ assertFalse(c.contains(bc));
+ assertFalse(c.contains(ab));
+ assertFalse(c.contains(de));
+
+ assertTrue(cd.contains(c));
+ assertTrue(bd.contains(c));
+ assertTrue(bc.contains(c));
+ assertFalse(ab.contains(c));
+ assertFalse(de.contains(c));
+
+ assertTrue(ae.contains(b));
+ assertTrue(ae.contains(ab));
+ assertTrue(ae.contains(bc));
+ assertTrue(ae.contains(cd));
+ assertTrue(ae.contains(de));
CharRange notb = CharRange.isNot('b');
CharRange notc = CharRange.isNot('c');
@@ -247,66 +247,66 @@ public class CharRangeTest {
CharRange allbutfirst = CharRange.isIn((char) 1, Character.MAX_VALUE);
// normal/negated
- assertEquals(false, c.contains(notc));
- assertEquals(false, c.contains(notbd));
- assertEquals(true, all.contains(notc));
- assertEquals(true, all.contains(notbd));
- assertEquals(false, allbutfirst.contains(notc));
- assertEquals(false, allbutfirst.contains(notbd));
+ assertFalse(c.contains(notc));
+ assertFalse(c.contains(notbd));
+ assertTrue(all.contains(notc));
+ assertTrue(all.contains(notbd));
+ assertFalse(allbutfirst.contains(notc));
+ assertFalse(allbutfirst.contains(notbd));
// negated/normal
- assertEquals(true, notc.contains(a));
- assertEquals(true, notc.contains(b));
- assertEquals(false, notc.contains(c));
- assertEquals(true, notc.contains(d));
- assertEquals(true, notc.contains(e));
-
- assertEquals(true, notc.contains(ab));
- assertEquals(false, notc.contains(bc));
- assertEquals(false, notc.contains(bd));
- assertEquals(false, notc.contains(cd));
- assertEquals(true, notc.contains(de));
- assertEquals(false, notc.contains(ae));
- assertEquals(false, notc.contains(all));
- assertEquals(false, notc.contains(allbutfirst));
-
- assertEquals(true, notbd.contains(a));
- assertEquals(false, notbd.contains(b));
- assertEquals(false, notbd.contains(c));
- assertEquals(false, notbd.contains(d));
- assertEquals(true, notbd.contains(e));
-
- assertEquals(true, notcd.contains(ab));
- assertEquals(false, notcd.contains(bc));
- assertEquals(false, notcd.contains(bd));
- assertEquals(false, notcd.contains(cd));
- assertEquals(false, notcd.contains(de));
- assertEquals(false, notcd.contains(ae));
- assertEquals(true, notcd.contains(ef));
- assertEquals(false, notcd.contains(all));
- assertEquals(false, notcd.contains(allbutfirst));
+ assertTrue(notc.contains(a));
+ assertTrue(notc.contains(b));
+ assertFalse(notc.contains(c));
+ assertTrue(notc.contains(d));
+ assertTrue(notc.contains(e));
+
+ assertTrue(notc.contains(ab));
+ assertFalse(notc.contains(bc));
+ assertFalse(notc.contains(bd));
+ assertFalse(notc.contains(cd));
+ assertTrue(notc.contains(de));
+ assertFalse(notc.contains(ae));
+ assertFalse(notc.contains(all));
+ assertFalse(notc.contains(allbutfirst));
+
+ assertTrue(notbd.contains(a));
+ assertFalse(notbd.contains(b));
+ assertFalse(notbd.contains(c));
+ assertFalse(notbd.contains(d));
+ assertTrue(notbd.contains(e));
+
+ assertTrue(notcd.contains(ab));
+ assertFalse(notcd.contains(bc));
+ assertFalse(notcd.contains(bd));
+ assertFalse(notcd.contains(cd));
+ assertFalse(notcd.contains(de));
+ assertFalse(notcd.contains(ae));
+ assertTrue(notcd.contains(ef));
+ assertFalse(notcd.contains(all));
+ assertFalse(notcd.contains(allbutfirst));
// negated/negated
- assertEquals(false, notc.contains(notb));
- assertEquals(true, notc.contains(notc));
- assertEquals(false, notc.contains(notd));
-
- assertEquals(false, notc.contains(notab));
- assertEquals(true, notc.contains(notbc));
- assertEquals(true, notc.contains(notbd));
- assertEquals(true, notc.contains(notcd));
- assertEquals(false, notc.contains(notde));
-
- assertEquals(false, notbd.contains(notb));
- assertEquals(false, notbd.contains(notc));
- assertEquals(false, notbd.contains(notd));
-
- assertEquals(false, notbd.contains(notab));
- assertEquals(false, notbd.contains(notbc));
- assertEquals(true, notbd.contains(notbd));
- assertEquals(false, notbd.contains(notcd));
- assertEquals(false, notbd.contains(notde));
- assertEquals(true, notbd.contains(notae));
+ assertFalse(notc.contains(notb));
+ assertTrue(notc.contains(notc));
+ assertFalse(notc.contains(notd));
+
+ assertFalse(notc.contains(notab));
+ assertTrue(notc.contains(notbc));
+ assertTrue(notc.contains(notbd));
+ assertTrue(notc.contains(notcd));
+ assertFalse(notc.contains(notde));
+
+ assertFalse(notbd.contains(notb));
+ assertFalse(notbd.contains(notc));
+ assertFalse(notbd.contains(notd));
+
+ assertFalse(notbd.contains(notab));
+ assertFalse(notbd.contains(notbc));
+ assertTrue(notbd.contains(notbd));
+ assertFalse(notbd.contains(notcd));
+ assertFalse(notbd.contains(notde));
+ assertTrue(notbd.contains(notae));
}
@Test
Modified: commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/CharSequenceUtilsTest.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/CharSequenceUtilsTest.java?rev=1387423&r1=1387422&r2=1387423&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/CharSequenceUtilsTest.java (original)
+++ commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/CharSequenceUtilsTest.java Wed Sep 19 01:08:04 2012
@@ -17,7 +17,9 @@
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 java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
@@ -39,9 +41,9 @@ public class CharSequenceUtilsTest {
assertNotNull(new CharSequenceUtils());
Constructor<?>[] cons = CharSequenceUtils.class.getDeclaredConstructors();
assertEquals(1, cons.length);
- assertEquals(true, Modifier.isPublic(cons[0].getModifiers()));
- assertEquals(true, Modifier.isPublic(CharSequenceUtils.class.getModifiers()));
- assertEquals(false, Modifier.isFinal(CharSequenceUtils.class.getModifiers()));
+ assertTrue(Modifier.isPublic(cons[0].getModifiers()));
+ assertTrue(Modifier.isPublic(CharSequenceUtils.class.getModifiers()));
+ assertFalse(Modifier.isFinal(CharSequenceUtils.class.getModifiers()));
}
//-----------------------------------------------------------------------
Modified: commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/CharSetTest.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/CharSetTest.java?rev=1387423&r1=1387422&r2=1387423&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/CharSetTest.java (original)
+++ commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/CharSetTest.java Wed Sep 19 01:08:04 2012
@@ -19,7 +19,9 @@
package org.apache.commons.lang3;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
import java.lang.reflect.Modifier;
@@ -35,8 +37,8 @@ public class CharSetTest {
//-----------------------------------------------------------------------
@Test
public void testClass() {
- assertEquals(true, Modifier.isPublic(CharSet.class.getModifiers()));
- assertEquals(false, Modifier.isFinal(CharSet.class.getModifiers()));
+ assertTrue(Modifier.isPublic(CharSet.class.getModifiers()));
+ assertFalse(Modifier.isFinal(CharSet.class.getModifiers()));
}
//-----------------------------------------------------------------------
@@ -109,35 +111,35 @@ public class CharSetTest {
set = CharSet.getInstance("abc");
array = set.getCharRanges();
assertEquals(3, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('a')));
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('b')));
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('c')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('a')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('b')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('c')));
set = CharSet.getInstance("a-ce-f");
array = set.getCharRanges();
assertEquals(2, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.isIn('a', 'c')));
- assertEquals(true, ArrayUtils.contains(array, CharRange.isIn('e', 'f')));
+ assertTrue(ArrayUtils.contains(array, CharRange.isIn('a', 'c')));
+ assertTrue(ArrayUtils.contains(array, CharRange.isIn('e', 'f')));
set = CharSet.getInstance("ae-f");
array = set.getCharRanges();
assertEquals(2, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('a')));
- assertEquals(true, ArrayUtils.contains(array, CharRange.isIn('e', 'f')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('a')));
+ assertTrue(ArrayUtils.contains(array, CharRange.isIn('e', 'f')));
set = CharSet.getInstance("e-fa");
array = set.getCharRanges();
assertEquals(2, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('a')));
- assertEquals(true, ArrayUtils.contains(array, CharRange.isIn('e', 'f')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('a')));
+ assertTrue(ArrayUtils.contains(array, CharRange.isIn('e', 'f')));
set = CharSet.getInstance("ae-fm-pz");
array = set.getCharRanges();
assertEquals(4, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('a')));
- assertEquals(true, ArrayUtils.contains(array, CharRange.isIn('e', 'f')));
- assertEquals(true, ArrayUtils.contains(array, CharRange.isIn('m', 'p')));
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('z')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('a')));
+ assertTrue(ArrayUtils.contains(array, CharRange.isIn('e', 'f')));
+ assertTrue(ArrayUtils.contains(array, CharRange.isIn('m', 'p')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('z')));
}
@Test
@@ -148,37 +150,37 @@ public class CharSetTest {
set = CharSet.getInstance("^abc");
array = set.getCharRanges();
assertEquals(3, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.isNot('a')));
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('b')));
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('c')));
+ assertTrue(ArrayUtils.contains(array, CharRange.isNot('a')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('b')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('c')));
set = CharSet.getInstance("b^ac");
array = set.getCharRanges();
assertEquals(3, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('b')));
- assertEquals(true, ArrayUtils.contains(array, CharRange.isNot('a')));
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('c')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('b')));
+ assertTrue(ArrayUtils.contains(array, CharRange.isNot('a')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('c')));
set = CharSet.getInstance("db^ac");
array = set.getCharRanges();
assertEquals(4, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('d')));
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('b')));
- assertEquals(true, ArrayUtils.contains(array, CharRange.isNot('a')));
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('c')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('d')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('b')));
+ assertTrue(ArrayUtils.contains(array, CharRange.isNot('a')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('c')));
set = CharSet.getInstance("^b^a");
array = set.getCharRanges();
assertEquals(2, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.isNot('b')));
- assertEquals(true, ArrayUtils.contains(array, CharRange.isNot('a')));
+ assertTrue(ArrayUtils.contains(array, CharRange.isNot('b')));
+ assertTrue(ArrayUtils.contains(array, CharRange.isNot('a')));
set = CharSet.getInstance("b^a-c^z");
array = set.getCharRanges();
assertEquals(3, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.isNotIn('a', 'c')));
- assertEquals(true, ArrayUtils.contains(array, CharRange.isNot('z')));
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('b')));
+ assertTrue(ArrayUtils.contains(array, CharRange.isNotIn('a', 'c')));
+ assertTrue(ArrayUtils.contains(array, CharRange.isNot('z')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('b')));
}
@Test
@@ -189,44 +191,44 @@ public class CharSetTest {
set = CharSet.getInstance("-");
array = set.getCharRanges();
assertEquals(1, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('-')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('-')));
set = CharSet.getInstance("--");
array = set.getCharRanges();
assertEquals(1, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('-')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('-')));
set = CharSet.getInstance("---");
array = set.getCharRanges();
assertEquals(1, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('-')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('-')));
set = CharSet.getInstance("----");
array = set.getCharRanges();
assertEquals(1, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('-')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('-')));
set = CharSet.getInstance("-a");
array = set.getCharRanges();
assertEquals(2, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('-')));
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('a')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('-')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('a')));
set = CharSet.getInstance("a-");
array = set.getCharRanges();
assertEquals(2, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('a')));
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('-')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('a')));
+ assertTrue(ArrayUtils.contains(array, CharRange.is('-')));
set = CharSet.getInstance("a--");
array = set.getCharRanges();
assertEquals(1, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.isIn('a', '-')));
+ assertTrue(ArrayUtils.contains(array, CharRange.isIn('a', '-')));
set = CharSet.getInstance("--a");
array = set.getCharRanges();
assertEquals(1, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.isIn('-', 'a')));
+ assertTrue(ArrayUtils.contains(array, CharRange.isIn('-', 'a')));
}
@Test
@@ -236,57 +238,57 @@ public class CharSetTest {
set = CharSet.getInstance("^");
array = set.getCharRanges();
assertEquals(1, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('^'))); // "^"
+ assertTrue(ArrayUtils.contains(array, CharRange.is('^'))); // "^"
set = CharSet.getInstance("^^");
array = set.getCharRanges();
assertEquals(1, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.isNot('^'))); // "^^"
+ assertTrue(ArrayUtils.contains(array, CharRange.isNot('^'))); // "^^"
set = CharSet.getInstance("^^^");
array = set.getCharRanges();
assertEquals(2, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.isNot('^'))); // "^^"
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('^'))); // "^"
+ assertTrue(ArrayUtils.contains(array, CharRange.isNot('^'))); // "^^"
+ assertTrue(ArrayUtils.contains(array, CharRange.is('^'))); // "^"
set = CharSet.getInstance("^^^^");
array = set.getCharRanges();
assertEquals(1, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.isNot('^'))); // "^^" x2
+ assertTrue(ArrayUtils.contains(array, CharRange.isNot('^'))); // "^^" x2
set = CharSet.getInstance("a^");
array = set.getCharRanges();
assertEquals(2, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('a'))); // "a"
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('^'))); // "^"
+ assertTrue(ArrayUtils.contains(array, CharRange.is('a'))); // "a"
+ assertTrue(ArrayUtils.contains(array, CharRange.is('^'))); // "^"
set = CharSet.getInstance("^a-");
array = set.getCharRanges();
assertEquals(2, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.isNot('a'))); // "^a"
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('-'))); // "-"
+ assertTrue(ArrayUtils.contains(array, CharRange.isNot('a'))); // "^a"
+ assertTrue(ArrayUtils.contains(array, CharRange.is('-'))); // "-"
set = CharSet.getInstance("^^-c");
array = set.getCharRanges();
assertEquals(1, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.isNotIn('^', 'c'))); // "^^-c"
+ assertTrue(ArrayUtils.contains(array, CharRange.isNotIn('^', 'c'))); // "^^-c"
set = CharSet.getInstance("^c-^");
array = set.getCharRanges();
assertEquals(1, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.isNotIn('c', '^'))); // "^c-^"
+ assertTrue(ArrayUtils.contains(array, CharRange.isNotIn('c', '^'))); // "^c-^"
set = CharSet.getInstance("^c-^d");
array = set.getCharRanges();
assertEquals(2, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.isNotIn('c', '^'))); // "^c-^"
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('d'))); // "d"
+ assertTrue(ArrayUtils.contains(array, CharRange.isNotIn('c', '^'))); // "^c-^"
+ assertTrue(ArrayUtils.contains(array, CharRange.is('d'))); // "d"
set = CharSet.getInstance("^^-");
array = set.getCharRanges();
assertEquals(2, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.isNot('^'))); // "^^"
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('-'))); // "-"
+ assertTrue(ArrayUtils.contains(array, CharRange.isNot('^'))); // "^^"
+ assertTrue(ArrayUtils.contains(array, CharRange.is('-'))); // "-"
}
@Test
@@ -296,46 +298,46 @@ public class CharSetTest {
set = CharSet.getInstance("a-^c");
array = set.getCharRanges();
- assertEquals(true, ArrayUtils.contains(array, CharRange.isIn('a', '^'))); // "a-^"
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('c'))); // "c"
- assertEquals(false, set.contains('b'));
- assertEquals(true, set.contains('^'));
- assertEquals(true, set.contains('_')); // between ^ and a
- assertEquals(true, set.contains('c'));
+ assertTrue(ArrayUtils.contains(array, CharRange.isIn('a', '^'))); // "a-^"
+ assertTrue(ArrayUtils.contains(array, CharRange.is('c'))); // "c"
+ assertFalse(set.contains('b'));
+ assertTrue(set.contains('^'));
+ assertTrue(set.contains('_')); // between ^ and a
+ assertTrue(set.contains('c'));
set = CharSet.getInstance("^a-^c");
array = set.getCharRanges();
- assertEquals(true, ArrayUtils.contains(array, CharRange.isNotIn('a', '^'))); // "^a-^"
- assertEquals(true, ArrayUtils.contains(array, CharRange.is('c'))); // "c"
- assertEquals(true, set.contains('b'));
- assertEquals(false, set.contains('^'));
- assertEquals(false, set.contains('_')); // between ^ and a
+ assertTrue(ArrayUtils.contains(array, CharRange.isNotIn('a', '^'))); // "^a-^"
+ assertTrue(ArrayUtils.contains(array, CharRange.is('c'))); // "c"
+ assertTrue(set.contains('b'));
+ assertFalse(set.contains('^'));
+ assertFalse(set.contains('_')); // between ^ and a
set = CharSet.getInstance("a- ^-- "); //contains everything
array = set.getCharRanges();
- assertEquals(true, ArrayUtils.contains(array, CharRange.isIn('a', ' '))); // "a- "
- assertEquals(true, ArrayUtils.contains(array, CharRange.isNotIn('-', ' '))); // "^-- "
- assertEquals(true, set.contains('#'));
- assertEquals(true, set.contains('^'));
- assertEquals(true, set.contains('a'));
- assertEquals(true, set.contains('*'));
- assertEquals(true, set.contains('A'));
+ assertTrue(ArrayUtils.contains(array, CharRange.isIn('a', ' '))); // "a- "
+ assertTrue(ArrayUtils.contains(array, CharRange.isNotIn('-', ' '))); // "^-- "
+ assertTrue(set.contains('#'));
+ assertTrue(set.contains('^'));
+ assertTrue(set.contains('a'));
+ assertTrue(set.contains('*'));
+ assertTrue(set.contains('A'));
set = CharSet.getInstance("^-b");
array = set.getCharRanges();
- assertEquals(true, ArrayUtils.contains(array, CharRange.isIn('^','b'))); // "^-b"
- assertEquals(true, set.contains('b'));
- assertEquals(true, set.contains('_')); // between ^ and a
- assertEquals(false, set.contains('A'));
- assertEquals(true, set.contains('^'));
+ assertTrue(ArrayUtils.contains(array, CharRange.isIn('^','b'))); // "^-b"
+ assertTrue(set.contains('b'));
+ assertTrue(set.contains('_')); // between ^ and a
+ assertFalse(set.contains('A'));
+ assertTrue(set.contains('^'));
set = CharSet.getInstance("b-^");
array = set.getCharRanges();
- assertEquals(true, ArrayUtils.contains(array, CharRange.isIn('^','b'))); // "b-^"
- assertEquals(true, set.contains('b'));
- assertEquals(true, set.contains('^'));
- assertEquals(true, set.contains('a')); // between ^ and b
- assertEquals(false, set.contains('c'));
+ assertTrue(ArrayUtils.contains(array, CharRange.isIn('^','b'))); // "b-^"
+ assertTrue(set.contains('b'));
+ assertTrue(set.contains('^'));
+ assertTrue(set.contains('a')); // between ^ and b
+ assertFalse(set.contains('c'));
}
//-----------------------------------------------------------------------
@@ -348,22 +350,22 @@ public class CharSetTest {
CharSet notatoc = CharSet.getInstance("^a-c");
CharSet notatoc2 = CharSet.getInstance("^a-c");
- assertEquals(false, abc.equals(null));
+ assertFalse(abc.equals(null));
- assertEquals(true, abc.equals(abc));
- assertEquals(true, abc.equals(abc2));
- assertEquals(false, abc.equals(atoc));
- assertEquals(false, abc.equals(notatoc));
-
- assertEquals(false, atoc.equals(abc));
- assertEquals(true, atoc.equals(atoc));
- assertEquals(true, atoc.equals(atoc2));
- assertEquals(false, atoc.equals(notatoc));
-
- assertEquals(false, notatoc.equals(abc));
- assertEquals(false, notatoc.equals(atoc));
- assertEquals(true, notatoc.equals(notatoc));
- assertEquals(true, notatoc.equals(notatoc2));
+ assertTrue(abc.equals(abc));
+ assertTrue(abc.equals(abc2));
+ assertFalse(abc.equals(atoc));
+ assertFalse(abc.equals(notatoc));
+
+ assertFalse(atoc.equals(abc));
+ assertTrue(atoc.equals(atoc));
+ assertTrue(atoc.equals(atoc2));
+ assertFalse(atoc.equals(notatoc));
+
+ assertFalse(notatoc.equals(abc));
+ assertFalse(notatoc.equals(atoc));
+ assertTrue(notatoc.equals(notatoc));
+ assertTrue(notatoc.equals(notatoc2));
}
@Test
@@ -392,35 +394,35 @@ public class CharSetTest {
CharSet bd = CharSet.getInstance("bd");
CharSet notbtod = CharSet.getInstance("^b-d");
- assertEquals(false, btod.contains('a'));
- assertEquals(true, btod.contains('b'));
- assertEquals(true, btod.contains('c'));
- assertEquals(true, btod.contains('d'));
- assertEquals(false, btod.contains('e'));
-
- assertEquals(false, bcd.contains('a'));
- assertEquals(true, bcd.contains('b'));
- assertEquals(true, bcd.contains('c'));
- assertEquals(true, bcd.contains('d'));
- assertEquals(false, bcd.contains('e'));
-
- assertEquals(false, bd.contains('a'));
- assertEquals(true, bd.contains('b'));
- assertEquals(false, bd.contains('c'));
- assertEquals(true, bd.contains('d'));
- assertEquals(false, bd.contains('e'));
-
- assertEquals(true, notbtod.contains('a'));
- assertEquals(false, notbtod.contains('b'));
- assertEquals(false, notbtod.contains('c'));
- assertEquals(false, notbtod.contains('d'));
- assertEquals(true, notbtod.contains('e'));
-
- assertEquals(false, dtob.contains('a'));
- assertEquals(true, dtob.contains('b'));
- assertEquals(true, dtob.contains('c'));
- assertEquals(true, dtob.contains('d'));
- assertEquals(false, dtob.contains('e'));
+ assertFalse(btod.contains('a'));
+ assertTrue(btod.contains('b'));
+ assertTrue(btod.contains('c'));
+ assertTrue(btod.contains('d'));
+ assertFalse(btod.contains('e'));
+
+ assertFalse(bcd.contains('a'));
+ assertTrue(bcd.contains('b'));
+ assertTrue(bcd.contains('c'));
+ assertTrue(bcd.contains('d'));
+ assertFalse(bcd.contains('e'));
+
+ assertFalse(bd.contains('a'));
+ assertTrue(bd.contains('b'));
+ assertFalse(bd.contains('c'));
+ assertTrue(bd.contains('d'));
+ assertFalse(bd.contains('e'));
+
+ assertTrue(notbtod.contains('a'));
+ assertFalse(notbtod.contains('b'));
+ assertFalse(notbtod.contains('c'));
+ assertFalse(notbtod.contains('d'));
+ assertTrue(notbtod.contains('e'));
+
+ assertFalse(dtob.contains('a'));
+ assertTrue(dtob.contains('b'));
+ assertTrue(dtob.contains('c'));
+ assertTrue(dtob.contains('d'));
+ assertFalse(dtob.contains('e'));
CharRange[] array = dtob.getCharRanges();
assertEquals("[b-d]", dtob.toString());
@@ -448,20 +450,20 @@ public class CharSetTest {
array = CharSet.ASCII_ALPHA.getCharRanges();
assertEquals(2, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.isIn('a', 'z')));
- assertEquals(true, ArrayUtils.contains(array, CharRange.isIn('A', 'Z')));
+ assertTrue(ArrayUtils.contains(array, CharRange.isIn('a', 'z')));
+ assertTrue(ArrayUtils.contains(array, CharRange.isIn('A', 'Z')));
array = CharSet.ASCII_ALPHA_LOWER.getCharRanges();
assertEquals(1, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.isIn('a', 'z')));
+ assertTrue(ArrayUtils.contains(array, CharRange.isIn('a', 'z')));
array = CharSet.ASCII_ALPHA_UPPER.getCharRanges();
assertEquals(1, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.isIn('A', 'Z')));
+ assertTrue(ArrayUtils.contains(array, CharRange.isIn('A', 'Z')));
array = CharSet.ASCII_NUMERIC.getCharRanges();
assertEquals(1, array.length);
- assertEquals(true, ArrayUtils.contains(array, CharRange.isIn('0', '9')));
+ assertTrue(ArrayUtils.contains(array, CharRange.isIn('0', '9')));
}
}
Modified: commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/CharSetUtilsTest.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/CharSetUtilsTest.java?rev=1387423&r1=1387422&r2=1387423&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/CharSetUtilsTest.java (original)
+++ commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/CharSetUtilsTest.java Wed Sep 19 01:08:04 2012
@@ -17,7 +17,9 @@
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 java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
@@ -37,9 +39,9 @@ public class CharSetUtilsTest {
assertNotNull(new CharSetUtils());
Constructor<?>[] cons = CharSetUtils.class.getDeclaredConstructors();
assertEquals(1, cons.length);
- assertEquals(true, Modifier.isPublic(cons[0].getModifiers()));
- assertEquals(true, Modifier.isPublic(CharSetUtils.class.getModifiers()));
- assertEquals(false, Modifier.isFinal(CharSetUtils.class.getModifiers()));
+ assertTrue(Modifier.isPublic(cons[0].getModifiers()));
+ assertTrue(Modifier.isPublic(CharSetUtils.class.getModifiers()));
+ assertFalse(Modifier.isFinal(CharSetUtils.class.getModifiers()));
}
//-----------------------------------------------------------------------
Modified: commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/ClassUtilsTest.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/ClassUtilsTest.java?rev=1387423&r1=1387422&r2=1387423&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/ClassUtilsTest.java (original)
+++ commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/ClassUtilsTest.java Wed Sep 19 01:08:04 2012
@@ -57,9 +57,9 @@ public class ClassUtilsTest {
assertNotNull(new ClassUtils());
Constructor<?>[] cons = ClassUtils.class.getDeclaredConstructors();
assertEquals(1, cons.length);
- assertEquals(true, Modifier.isPublic(cons[0].getModifiers()));
- assertEquals(true, Modifier.isPublic(ClassUtils.class.getModifiers()));
- assertEquals(false, Modifier.isFinal(ClassUtils.class.getModifiers()));
+ assertTrue(Modifier.isPublic(cons[0].getModifiers()));
+ assertTrue(Modifier.isPublic(ClassUtils.class.getModifiers()));
+ assertFalse(Modifier.isFinal(ClassUtils.class.getModifiers()));
}
// -------------------------------------------------------------------------
@@ -320,13 +320,13 @@ public class ClassUtilsTest {
// -------------------------------------------------------------------------
@Test
public void test_isInnerClass_Class() {
- assertEquals(true, ClassUtils.isInnerClass(Inner.class));
- assertEquals(true, ClassUtils.isInnerClass(Map.Entry.class));
- assertEquals(true, ClassUtils.isInnerClass(new Cloneable() {
+ assertTrue(ClassUtils.isInnerClass(Inner.class));
+ assertTrue(ClassUtils.isInnerClass(Map.Entry.class));
+ assertTrue(ClassUtils.isInnerClass(new Cloneable() {
}.getClass()));
- assertEquals(false, ClassUtils.isInnerClass(this.getClass()));
- assertEquals(false, ClassUtils.isInnerClass(String.class));
- assertEquals(false, ClassUtils.isInnerClass(null));
+ assertFalse(ClassUtils.isInnerClass(this.getClass()));
+ assertFalse(ClassUtils.isInnerClass(String.class));
+ assertFalse(ClassUtils.isInnerClass(null));
}
// -------------------------------------------------------------------------