commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From s...@apache.org
Subject svn commit: r1387424 [1/2] - in /commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3: ./ exception/ math/ mutable/ text/ time/
Date Wed, 19 Sep 2012 01:29:23 GMT
Author: sebb
Date: Wed Sep 19 01:29:22 2012
New Revision: 1387424

URL: http://svn.apache.org/viewvc?rev=1387424&view=rev
Log:
Simplify boolean tests and avoid boxing

Modified:
    commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java
    commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/StringUtilsIsTest.java
    commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/StringUtilsTrimEmptyTest.java
    commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/SystemUtilsTest.java
    commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/ValidateTest.java
    commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/exception/ExceptionUtilsTest.java
    commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/math/FractionTest.java
    commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableByteTest.java
    commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableDoubleTest.java
    commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableFloatTest.java
    commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableIntTest.java
    commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableLongTest.java
    commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableObjectTest.java
    commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableShortTest.java
    commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/text/StrBuilderTest.java
    commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/text/StrSubstitutorTest.java
    commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/text/StrTokenizerTest.java
    commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/text/WordUtilsTest.java
    commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/time/DateFormatUtilsTest.java
    commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/time/DateUtilsTest.java
    commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/time/DurationFormatUtilsTest.java

Modified: commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java?rev=1387424&r1=1387423&r2=1387424&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java (original)
+++ commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java Wed Sep 19 01:29:22 2012
@@ -63,29 +63,29 @@ public class StringUtilsEqualsIndexOfTes
 
     @Test
     public void testContains_Char() {
-        assertEquals(false, StringUtils.contains(null, ' '));
-        assertEquals(false, StringUtils.contains("", ' '));
-        assertEquals(false, StringUtils.contains("", null));
-        assertEquals(false, StringUtils.contains(null, null));
-        assertEquals(true, StringUtils.contains("abc", 'a'));
-        assertEquals(true, StringUtils.contains("abc", 'b'));
-        assertEquals(true, StringUtils.contains("abc", 'c'));
-        assertEquals(false, StringUtils.contains("abc", 'z'));
+        assertFalse(StringUtils.contains(null, ' '));
+        assertFalse(StringUtils.contains("", ' '));
+        assertFalse(StringUtils.contains("", null));
+        assertFalse(StringUtils.contains(null, null));
+        assertTrue(StringUtils.contains("abc", 'a'));
+        assertTrue(StringUtils.contains("abc", 'b'));
+        assertTrue(StringUtils.contains("abc", 'c'));
+        assertFalse(StringUtils.contains("abc", 'z'));
     }
 
     @Test
     public void testContains_String() {
-        assertEquals(false, StringUtils.contains(null, null));
-        assertEquals(false, StringUtils.contains(null, ""));
-        assertEquals(false, StringUtils.contains(null, "a"));
-        assertEquals(false, StringUtils.contains("", null));
-        assertEquals(true, StringUtils.contains("", ""));
-        assertEquals(false, StringUtils.contains("", "a"));
-        assertEquals(true, StringUtils.contains("abc", "a"));
-        assertEquals(true, StringUtils.contains("abc", "b"));
-        assertEquals(true, StringUtils.contains("abc", "c"));
-        assertEquals(true, StringUtils.contains("abc", "abc"));
-        assertEquals(false, StringUtils.contains("abc", "z"));
+        assertFalse(StringUtils.contains(null, null));
+        assertFalse(StringUtils.contains(null, ""));
+        assertFalse(StringUtils.contains(null, "a"));
+        assertFalse(StringUtils.contains("", null));
+        assertTrue(StringUtils.contains("", ""));
+        assertFalse(StringUtils.contains("", "a"));
+        assertTrue(StringUtils.contains("abc", "a"));
+        assertTrue(StringUtils.contains("abc", "b"));
+        assertTrue(StringUtils.contains("abc", "c"));
+        assertTrue(StringUtils.contains("abc", "abc"));
+        assertFalse(StringUtils.contains("abc", "z"));
     }
 
     /**
@@ -94,13 +94,13 @@ public class StringUtilsEqualsIndexOfTes
     @Test
     public void testContains_StringWithBadSupplementaryChars() {
         // Test edge case: 1/2 of a (broken) supplementary char
-        assertEquals(false, StringUtils.contains(CharUSuppCharHigh, CharU20001));
-        assertEquals(false, StringUtils.contains(CharUSuppCharLow, CharU20001));
-        assertEquals(false, StringUtils.contains(CharU20001, CharUSuppCharHigh));
+        assertFalse(StringUtils.contains(CharUSuppCharHigh, CharU20001));
+        assertFalse(StringUtils.contains(CharUSuppCharLow, CharU20001));
+        assertFalse(StringUtils.contains(CharU20001, CharUSuppCharHigh));
         assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
-        assertEquals(true, StringUtils.contains(CharU20001, CharUSuppCharLow));
-        assertEquals(true, StringUtils.contains(CharU20001 + CharUSuppCharLow + "a", "a"));
-        assertEquals(true, StringUtils.contains(CharU20001 + CharUSuppCharHigh + "a", "a"));
+        assertTrue(StringUtils.contains(CharU20001, CharUSuppCharLow));
+        assertTrue(StringUtils.contains(CharU20001 + CharUSuppCharLow + "a", "a"));
+        assertTrue(StringUtils.contains(CharU20001 + CharUSuppCharHigh + "a", "a"));
     }
 
     /**
@@ -108,10 +108,10 @@ public class StringUtilsEqualsIndexOfTes
      */
     @Test
     public void testContains_StringWithSupplementaryChars() {
-        assertEquals(true, StringUtils.contains(CharU20000 + CharU20001, CharU20000));
-        assertEquals(true, StringUtils.contains(CharU20000 + CharU20001, CharU20001));
-        assertEquals(true, StringUtils.contains(CharU20000, CharU20000));
-        assertEquals(false, StringUtils.contains(CharU20000, CharU20001));
+        assertTrue(StringUtils.contains(CharU20000 + CharU20001, CharU20000));
+        assertTrue(StringUtils.contains(CharU20000 + CharU20001, CharU20001));
+        assertTrue(StringUtils.contains(CharU20000, CharU20000));
+        assertFalse(StringUtils.contains(CharU20000, CharU20001));
     }
 
     @Test
@@ -137,13 +137,13 @@ public class StringUtilsEqualsIndexOfTes
     @Test
     public void testContainsAny_StringCharArrayWithBadSupplementaryChars() {
         // Test edge case: 1/2 of a (broken) supplementary char
-        assertEquals(false, StringUtils.containsAny(CharUSuppCharHigh, CharU20001.toCharArray()));
-        assertEquals(false, StringUtils.containsAny("abc" + CharUSuppCharHigh + "xyz", CharU20001.toCharArray()));
+        assertFalse(StringUtils.containsAny(CharUSuppCharHigh, CharU20001.toCharArray()));
+        assertFalse(StringUtils.containsAny("abc" + CharUSuppCharHigh + "xyz", CharU20001.toCharArray()));
         assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
-        assertEquals(false, StringUtils.containsAny(CharUSuppCharLow, CharU20001.toCharArray()));
-        assertEquals(false, StringUtils.containsAny(CharU20001, CharUSuppCharHigh.toCharArray()));
+        assertFalse(StringUtils.containsAny(CharUSuppCharLow, CharU20001.toCharArray()));
+        assertFalse(StringUtils.containsAny(CharU20001, CharUSuppCharHigh.toCharArray()));
         assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
-        assertEquals(true, StringUtils.containsAny(CharU20001, CharUSuppCharLow.toCharArray()));
+        assertTrue(StringUtils.containsAny(CharU20001, CharUSuppCharLow.toCharArray()));
     }
 
     /**
@@ -151,19 +151,19 @@ public class StringUtilsEqualsIndexOfTes
      */
     @Test
     public void testContainsAny_StringCharArrayWithSupplementaryChars() {
-        assertEquals(true, StringUtils.containsAny(CharU20000 + CharU20001, CharU20000.toCharArray()));
-        assertEquals(true, StringUtils.containsAny("a" + CharU20000 + CharU20001, "a".toCharArray()));
-        assertEquals(true, StringUtils.containsAny(CharU20000 + "a" + CharU20001, "a".toCharArray()));
-        assertEquals(true, StringUtils.containsAny(CharU20000 + CharU20001 + "a", "a".toCharArray()));
-        assertEquals(true, StringUtils.containsAny(CharU20000 + CharU20001, CharU20001.toCharArray()));
-        assertEquals(true, StringUtils.containsAny(CharU20000, CharU20000.toCharArray()));
+        assertTrue(StringUtils.containsAny(CharU20000 + CharU20001, CharU20000.toCharArray()));
+        assertTrue(StringUtils.containsAny("a" + CharU20000 + CharU20001, "a".toCharArray()));
+        assertTrue(StringUtils.containsAny(CharU20000 + "a" + CharU20001, "a".toCharArray()));
+        assertTrue(StringUtils.containsAny(CharU20000 + CharU20001 + "a", "a".toCharArray()));
+        assertTrue(StringUtils.containsAny(CharU20000 + CharU20001, CharU20001.toCharArray()));
+        assertTrue(StringUtils.containsAny(CharU20000, CharU20000.toCharArray()));
         // Sanity check:
         assertEquals(-1, CharU20000.indexOf(CharU20001));
         assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
         assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
         // Test:
-        assertEquals(false, StringUtils.containsAny(CharU20000, CharU20001.toCharArray()));
-        assertEquals(false, StringUtils.containsAny(CharU20001, CharU20000.toCharArray()));
+        assertFalse(StringUtils.containsAny(CharU20000, CharU20001.toCharArray()));
+        assertFalse(StringUtils.containsAny(CharU20001, CharU20000.toCharArray()));
     }
 
     @Test
@@ -189,12 +189,12 @@ public class StringUtilsEqualsIndexOfTes
     @Test
     public void testContainsAny_StringWithBadSupplementaryChars() {
         // Test edge case: 1/2 of a (broken) supplementary char
-        assertEquals(false, StringUtils.containsAny(CharUSuppCharHigh, CharU20001));
+        assertFalse(StringUtils.containsAny(CharUSuppCharHigh, CharU20001));
         assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
-        assertEquals(false, StringUtils.containsAny(CharUSuppCharLow, CharU20001));
-        assertEquals(false, StringUtils.containsAny(CharU20001, CharUSuppCharHigh));
+        assertFalse(StringUtils.containsAny(CharUSuppCharLow, CharU20001));
+        assertFalse(StringUtils.containsAny(CharU20001, CharUSuppCharHigh));
         assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
-        assertEquals(true, StringUtils.containsAny(CharU20001, CharUSuppCharLow));
+        assertTrue(StringUtils.containsAny(CharU20001, CharUSuppCharLow));
     }
 
     /**
@@ -202,16 +202,16 @@ public class StringUtilsEqualsIndexOfTes
      */
     @Test
     public void testContainsAny_StringWithSupplementaryChars() {
-        assertEquals(true, StringUtils.containsAny(CharU20000 + CharU20001, CharU20000));
-        assertEquals(true, StringUtils.containsAny(CharU20000 + CharU20001, CharU20001));
-        assertEquals(true, StringUtils.containsAny(CharU20000, CharU20000));
+        assertTrue(StringUtils.containsAny(CharU20000 + CharU20001, CharU20000));
+        assertTrue(StringUtils.containsAny(CharU20000 + CharU20001, CharU20001));
+        assertTrue(StringUtils.containsAny(CharU20000, CharU20000));
         // Sanity check:
         assertEquals(-1, CharU20000.indexOf(CharU20001));
         assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
         assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
         // Test:
-        assertEquals(false, StringUtils.containsAny(CharU20000, CharU20001));
-        assertEquals(false, StringUtils.containsAny(CharU20001, CharU20000));
+        assertFalse(StringUtils.containsAny(CharU20000, CharU20001));
+        assertFalse(StringUtils.containsAny(CharU20001, CharU20000));
     }
 
     @Test
@@ -293,21 +293,21 @@ public class StringUtilsEqualsIndexOfTes
         char[] chars2= {'.'};
         char[] chars3= {'c', 'd'};
         char[] emptyChars = new char[0];
-        assertEquals(true, StringUtils.containsNone(null, (char[]) null));
-        assertEquals(true, StringUtils.containsNone("", (char[]) null));
-        assertEquals(true, StringUtils.containsNone(null, emptyChars));
-        assertEquals(true, StringUtils.containsNone(str1, emptyChars));
-        assertEquals(true, StringUtils.containsNone("", emptyChars));
-        assertEquals(true, StringUtils.containsNone("", chars1));
-        assertEquals(true, StringUtils.containsNone(str1, chars1));
-        assertEquals(true, StringUtils.containsNone(str1, chars2));
-        assertEquals(true, StringUtils.containsNone(str1, chars3));
-        assertEquals(false, StringUtils.containsNone(str2, chars1));
-        assertEquals(true, StringUtils.containsNone(str2, chars2));
-        assertEquals(true, StringUtils.containsNone(str2, chars3));
-        assertEquals(false, StringUtils.containsNone(str3, chars1));
-        assertEquals(false, StringUtils.containsNone(str3, chars2));
-        assertEquals(true, StringUtils.containsNone(str3, chars3));
+        assertTrue(StringUtils.containsNone(null, (char[]) null));
+        assertTrue(StringUtils.containsNone("", (char[]) null));
+        assertTrue(StringUtils.containsNone(null, emptyChars));
+        assertTrue(StringUtils.containsNone(str1, emptyChars));
+        assertTrue(StringUtils.containsNone("", emptyChars));
+        assertTrue(StringUtils.containsNone("", chars1));
+        assertTrue(StringUtils.containsNone(str1, chars1));
+        assertTrue(StringUtils.containsNone(str1, chars2));
+        assertTrue(StringUtils.containsNone(str1, chars3));
+        assertFalse(StringUtils.containsNone(str2, chars1));
+        assertTrue(StringUtils.containsNone(str2, chars2));
+        assertTrue(StringUtils.containsNone(str2, chars3));
+        assertFalse(StringUtils.containsNone(str3, chars1));
+        assertFalse(StringUtils.containsNone(str3, chars2));
+        assertTrue(StringUtils.containsNone(str3, chars3));
     }
 
     /**
@@ -316,13 +316,13 @@ public class StringUtilsEqualsIndexOfTes
     @Test
     public void testContainsNone_CharArrayWithBadSupplementaryChars() {
         // Test edge case: 1/2 of a (broken) supplementary char
-        assertEquals(true, StringUtils.containsNone(CharUSuppCharHigh, CharU20001.toCharArray()));
+        assertTrue(StringUtils.containsNone(CharUSuppCharHigh, CharU20001.toCharArray()));
         assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
-        assertEquals(true, StringUtils.containsNone(CharUSuppCharLow, CharU20001.toCharArray()));
+        assertTrue(StringUtils.containsNone(CharUSuppCharLow, CharU20001.toCharArray()));
         assertEquals(-1, CharU20001.indexOf(CharUSuppCharHigh));
-        assertEquals(true, StringUtils.containsNone(CharU20001, CharUSuppCharHigh.toCharArray()));
+        assertTrue(StringUtils.containsNone(CharU20001, CharUSuppCharHigh.toCharArray()));
         assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
-        assertEquals(false, StringUtils.containsNone(CharU20001, CharUSuppCharLow.toCharArray()));
+        assertFalse(StringUtils.containsNone(CharU20001, CharUSuppCharLow.toCharArray()));
     }
 
     /**
@@ -330,16 +330,16 @@ public class StringUtilsEqualsIndexOfTes
      */
     @Test
     public void testContainsNone_CharArrayWithSupplementaryChars() {
-        assertEquals(false, StringUtils.containsNone(CharU20000 + CharU20001, CharU20000.toCharArray()));
-        assertEquals(false, StringUtils.containsNone(CharU20000 + CharU20001, CharU20001.toCharArray()));
-        assertEquals(false, StringUtils.containsNone(CharU20000, CharU20000.toCharArray()));
+        assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20000.toCharArray()));
+        assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20001.toCharArray()));
+        assertFalse(StringUtils.containsNone(CharU20000, CharU20000.toCharArray()));
         // Sanity check:
         assertEquals(-1, CharU20000.indexOf(CharU20001));
         assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
         assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
         // Test:
-        assertEquals(true, StringUtils.containsNone(CharU20000, CharU20001.toCharArray()));
-        assertEquals(true, StringUtils.containsNone(CharU20001, CharU20000.toCharArray()));
+        assertTrue(StringUtils.containsNone(CharU20000, CharU20001.toCharArray()));
+        assertTrue(StringUtils.containsNone(CharU20001, CharU20000.toCharArray()));
     }
 
     @Test
@@ -350,21 +350,21 @@ public class StringUtilsEqualsIndexOfTes
         String chars1= "b";
         String chars2= ".";
         String chars3= "cd";
-        assertEquals(true, StringUtils.containsNone(null, (String) null));
-        assertEquals(true, StringUtils.containsNone("", (String) null));
-        assertEquals(true, StringUtils.containsNone(null, ""));
-        assertEquals(true, StringUtils.containsNone(str1, ""));
-        assertEquals(true, StringUtils.containsNone("", ""));
-        assertEquals(true, StringUtils.containsNone("", chars1));
-        assertEquals(true, StringUtils.containsNone(str1, chars1));
-        assertEquals(true, StringUtils.containsNone(str1, chars2));
-        assertEquals(true, StringUtils.containsNone(str1, chars3));
-        assertEquals(false, StringUtils.containsNone(str2, chars1));
-        assertEquals(true, StringUtils.containsNone(str2, chars2));
-        assertEquals(true, StringUtils.containsNone(str2, chars3));
-        assertEquals(false, StringUtils.containsNone(str3, chars1));
-        assertEquals(false, StringUtils.containsNone(str3, chars2));
-        assertEquals(true, StringUtils.containsNone(str3, chars3));
+        assertTrue(StringUtils.containsNone(null, (String) null));
+        assertTrue(StringUtils.containsNone("", (String) null));
+        assertTrue(StringUtils.containsNone(null, ""));
+        assertTrue(StringUtils.containsNone(str1, ""));
+        assertTrue(StringUtils.containsNone("", ""));
+        assertTrue(StringUtils.containsNone("", chars1));
+        assertTrue(StringUtils.containsNone(str1, chars1));
+        assertTrue(StringUtils.containsNone(str1, chars2));
+        assertTrue(StringUtils.containsNone(str1, chars3));
+        assertFalse(StringUtils.containsNone(str2, chars1));
+        assertTrue(StringUtils.containsNone(str2, chars2));
+        assertTrue(StringUtils.containsNone(str2, chars3));
+        assertFalse(StringUtils.containsNone(str3, chars1));
+        assertFalse(StringUtils.containsNone(str3, chars2));
+        assertTrue(StringUtils.containsNone(str3, chars3));
     }
 
     /**
@@ -373,13 +373,13 @@ public class StringUtilsEqualsIndexOfTes
     @Test
     public void testContainsNone_StringWithBadSupplementaryChars() {
         // Test edge case: 1/2 of a (broken) supplementary char
-        assertEquals(true, StringUtils.containsNone(CharUSuppCharHigh, CharU20001));
+        assertTrue(StringUtils.containsNone(CharUSuppCharHigh, CharU20001));
         assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
-        assertEquals(true, StringUtils.containsNone(CharUSuppCharLow, CharU20001));
+        assertTrue(StringUtils.containsNone(CharUSuppCharLow, CharU20001));
         assertEquals(-1, CharU20001.indexOf(CharUSuppCharHigh));
-        assertEquals(true, StringUtils.containsNone(CharU20001, CharUSuppCharHigh));
+        assertTrue(StringUtils.containsNone(CharU20001, CharUSuppCharHigh));
         assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
-        assertEquals(false, StringUtils.containsNone(CharU20001, CharUSuppCharLow));
+        assertFalse(StringUtils.containsNone(CharU20001, CharUSuppCharLow));
     }
 
     /**
@@ -387,16 +387,16 @@ public class StringUtilsEqualsIndexOfTes
      */
     @Test
     public void testContainsNone_StringWithSupplementaryChars() {
-        assertEquals(false, StringUtils.containsNone(CharU20000 + CharU20001, CharU20000));
-        assertEquals(false, StringUtils.containsNone(CharU20000 + CharU20001, CharU20001));
-        assertEquals(false, StringUtils.containsNone(CharU20000, CharU20000));
+        assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20000));
+        assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20001));
+        assertFalse(StringUtils.containsNone(CharU20000, CharU20000));
         // Sanity check:
         assertEquals(-1, CharU20000.indexOf(CharU20001));
         assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
         assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
         // Test:
-        assertEquals(true, StringUtils.containsNone(CharU20000, CharU20001));
-        assertEquals(true, StringUtils.containsNone(CharU20001, CharU20000));
+        assertTrue(StringUtils.containsNone(CharU20000, CharU20001));
+        assertTrue(StringUtils.containsNone(CharU20001, CharU20000));
     }
 
     @Test
@@ -408,21 +408,21 @@ public class StringUtilsEqualsIndexOfTes
         char[] chars2= {'a'};
         char[] chars3= {'a', 'b'};
         char[] emptyChars = new char[0];
-        assertEquals(false, StringUtils.containsOnly(null, (char[]) null));
-        assertEquals(false, StringUtils.containsOnly("", (char[]) null));
-        assertEquals(false, StringUtils.containsOnly(null, emptyChars));
-        assertEquals(false, StringUtils.containsOnly(str1, emptyChars));
-        assertEquals(true, StringUtils.containsOnly("", emptyChars));
-        assertEquals(true, StringUtils.containsOnly("", chars1));
-        assertEquals(false, StringUtils.containsOnly(str1, chars1));
-        assertEquals(true, StringUtils.containsOnly(str1, chars2));
-        assertEquals(true, StringUtils.containsOnly(str1, chars3));
-        assertEquals(true, StringUtils.containsOnly(str2, chars1));
-        assertEquals(false, StringUtils.containsOnly(str2, chars2));
-        assertEquals(true, StringUtils.containsOnly(str2, chars3));
-        assertEquals(false, StringUtils.containsOnly(str3, chars1));
-        assertEquals(false, StringUtils.containsOnly(str3, chars2));
-        assertEquals(true, StringUtils.containsOnly(str3, chars3));
+        assertFalse(StringUtils.containsOnly(null, (char[]) null));
+        assertFalse(StringUtils.containsOnly("", (char[]) null));
+        assertFalse(StringUtils.containsOnly(null, emptyChars));
+        assertFalse(StringUtils.containsOnly(str1, emptyChars));
+        assertTrue(StringUtils.containsOnly("", emptyChars));
+        assertTrue(StringUtils.containsOnly("", chars1));
+        assertFalse(StringUtils.containsOnly(str1, chars1));
+        assertTrue(StringUtils.containsOnly(str1, chars2));
+        assertTrue(StringUtils.containsOnly(str1, chars3));
+        assertTrue(StringUtils.containsOnly(str2, chars1));
+        assertFalse(StringUtils.containsOnly(str2, chars2));
+        assertTrue(StringUtils.containsOnly(str2, chars3));
+        assertFalse(StringUtils.containsOnly(str3, chars1));
+        assertFalse(StringUtils.containsOnly(str3, chars2));
+        assertTrue(StringUtils.containsOnly(str3, chars3));
     }
 
     @Test
@@ -433,21 +433,21 @@ public class StringUtilsEqualsIndexOfTes
         String chars1= "b";
         String chars2= "a";
         String chars3= "ab";
-        assertEquals(false, StringUtils.containsOnly(null, (String) null));
-        assertEquals(false, StringUtils.containsOnly("", (String) null));
-        assertEquals(false, StringUtils.containsOnly(null, ""));
-        assertEquals(false, StringUtils.containsOnly(str1, ""));
-        assertEquals(true, StringUtils.containsOnly("", ""));
-        assertEquals(true, StringUtils.containsOnly("", chars1));
-        assertEquals(false, StringUtils.containsOnly(str1, chars1));
-        assertEquals(true, StringUtils.containsOnly(str1, chars2));
-        assertEquals(true, StringUtils.containsOnly(str1, chars3));
-        assertEquals(true, StringUtils.containsOnly(str2, chars1));
-        assertEquals(false, StringUtils.containsOnly(str2, chars2));
-        assertEquals(true, StringUtils.containsOnly(str2, chars3));
-        assertEquals(false, StringUtils.containsOnly(str3, chars1));
-        assertEquals(false, StringUtils.containsOnly(str3, chars2));
-        assertEquals(true, StringUtils.containsOnly(str3, chars3));
+        assertFalse(StringUtils.containsOnly(null, (String) null));
+        assertFalse(StringUtils.containsOnly("", (String) null));
+        assertFalse(StringUtils.containsOnly(null, ""));
+        assertFalse(StringUtils.containsOnly(str1, ""));
+        assertTrue(StringUtils.containsOnly("", ""));
+        assertTrue(StringUtils.containsOnly("", chars1));
+        assertFalse(StringUtils.containsOnly(str1, chars1));
+        assertTrue(StringUtils.containsOnly(str1, chars2));
+        assertTrue(StringUtils.containsOnly(str1, chars3));
+        assertTrue(StringUtils.containsOnly(str2, chars1));
+        assertFalse(StringUtils.containsOnly(str2, chars2));
+        assertTrue(StringUtils.containsOnly(str2, chars3));
+        assertFalse(StringUtils.containsOnly(str3, chars1));
+        assertFalse(StringUtils.containsOnly(str3, chars2));
+        assertTrue(StringUtils.containsOnly(str3, chars3));
     }
 
     @Test
@@ -541,15 +541,15 @@ public class StringUtilsEqualsIndexOfTes
 
     @Test
     public void testEqualsIgnoreCase() {
-        assertEquals(true, StringUtils.equalsIgnoreCase(null, null));
-        assertEquals(true, StringUtils.equalsIgnoreCase(FOO, FOO));
-        assertEquals(true, StringUtils.equalsIgnoreCase(FOO, new String(new char[] { 'f', 'o', 'o' })));
-        assertEquals(true, StringUtils.equalsIgnoreCase(FOO, new String(new char[] { 'f', 'O', 'O' })));
-        assertEquals(false, StringUtils.equalsIgnoreCase(FOO, BAR));
-        assertEquals(false, StringUtils.equalsIgnoreCase(FOO, null));
-        assertEquals(false, StringUtils.equalsIgnoreCase(null, FOO));
-        assertEquals(true, StringUtils.equalsIgnoreCase("",""));
-        assertEquals(false, StringUtils.equalsIgnoreCase("abcd","abcd "));
+        assertTrue(StringUtils.equalsIgnoreCase(null, null));
+        assertTrue(StringUtils.equalsIgnoreCase(FOO, FOO));
+        assertTrue(StringUtils.equalsIgnoreCase(FOO, new String(new char[] { 'f', 'o', 'o' })));
+        assertTrue(StringUtils.equalsIgnoreCase(FOO, new String(new char[] { 'f', 'O', 'O' })));
+        assertFalse(StringUtils.equalsIgnoreCase(FOO, BAR));
+        assertFalse(StringUtils.equalsIgnoreCase(FOO, null));
+        assertFalse(StringUtils.equalsIgnoreCase(null, FOO));
+        assertTrue(StringUtils.equalsIgnoreCase("",""));
+        assertFalse(StringUtils.equalsIgnoreCase("abcd","abcd "));
     }
 
     //-----------------------------------------------------------------------

Modified: commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/StringUtilsIsTest.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/StringUtilsIsTest.java?rev=1387424&r1=1387423&r2=1387424&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/StringUtilsIsTest.java (original)
+++ commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/StringUtilsIsTest.java Wed Sep 19 01:29:22 2012
@@ -16,7 +16,8 @@
  */
 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;
 
@@ -31,142 +32,142 @@ public class StringUtilsIsTest  {
 
     @Test
     public void testIsAlpha() {
-        assertEquals(false, StringUtils.isAlpha(null));
-        assertEquals(false, StringUtils.isAlpha(""));
-        assertEquals(false, StringUtils.isAlpha(" "));
-        assertEquals(true, StringUtils.isAlpha("a"));
-        assertEquals(true, StringUtils.isAlpha("A"));
-        assertEquals(true, StringUtils.isAlpha("kgKgKgKgkgkGkjkjlJlOKLgHdGdHgl"));
-        assertEquals(false, StringUtils.isAlpha("ham kso"));
-        assertEquals(false, StringUtils.isAlpha("1"));
-        assertEquals(false, StringUtils.isAlpha("hkHKHik6iUGHKJgU7tUJgKJGI87GIkug"));
-        assertEquals(false, StringUtils.isAlpha("_"));
-        assertEquals(false, StringUtils.isAlpha("hkHKHik*khbkuh"));
+        assertFalse(StringUtils.isAlpha(null));
+        assertFalse(StringUtils.isAlpha(""));
+        assertFalse(StringUtils.isAlpha(" "));
+        assertTrue(StringUtils.isAlpha("a"));
+        assertTrue(StringUtils.isAlpha("A"));
+        assertTrue(StringUtils.isAlpha("kgKgKgKgkgkGkjkjlJlOKLgHdGdHgl"));
+        assertFalse(StringUtils.isAlpha("ham kso"));
+        assertFalse(StringUtils.isAlpha("1"));
+        assertFalse(StringUtils.isAlpha("hkHKHik6iUGHKJgU7tUJgKJGI87GIkug"));
+        assertFalse(StringUtils.isAlpha("_"));
+        assertFalse(StringUtils.isAlpha("hkHKHik*khbkuh"));
     }
 
     @Test
     public void testIsAlphanumeric() {
-        assertEquals(false, StringUtils.isAlphanumeric(null));
-        assertEquals(false, StringUtils.isAlphanumeric(""));
-        assertEquals(false, StringUtils.isAlphanumeric(" "));
-        assertEquals(true, StringUtils.isAlphanumeric("a"));
-        assertEquals(true, StringUtils.isAlphanumeric("A"));
-        assertEquals(true, StringUtils.isAlphanumeric("kgKgKgKgkgkGkjkjlJlOKLgHdGdHgl"));
-        assertEquals(false, StringUtils.isAlphanumeric("ham kso"));
-        assertEquals(true, StringUtils.isAlphanumeric("1"));
-        assertEquals(true, StringUtils.isAlphanumeric("hkHKHik6iUGHKJgU7tUJgKJGI87GIkug"));
-        assertEquals(false, StringUtils.isAlphanumeric("_"));
-        assertEquals(false, StringUtils.isAlphanumeric("hkHKHik*khbkuh"));
+        assertFalse(StringUtils.isAlphanumeric(null));
+        assertFalse(StringUtils.isAlphanumeric(""));
+        assertFalse(StringUtils.isAlphanumeric(" "));
+        assertTrue(StringUtils.isAlphanumeric("a"));
+        assertTrue(StringUtils.isAlphanumeric("A"));
+        assertTrue(StringUtils.isAlphanumeric("kgKgKgKgkgkGkjkjlJlOKLgHdGdHgl"));
+        assertFalse(StringUtils.isAlphanumeric("ham kso"));
+        assertTrue(StringUtils.isAlphanumeric("1"));
+        assertTrue(StringUtils.isAlphanumeric("hkHKHik6iUGHKJgU7tUJgKJGI87GIkug"));
+        assertFalse(StringUtils.isAlphanumeric("_"));
+        assertFalse(StringUtils.isAlphanumeric("hkHKHik*khbkuh"));
     }
 
     @Test
     public void testIsWhitespace() {
-        assertEquals(false, StringUtils.isWhitespace(null));
-        assertEquals(true, StringUtils.isWhitespace(""));
-        assertEquals(true, StringUtils.isWhitespace(" "));
-        assertEquals(true, StringUtils.isWhitespace("\t \n \t"));
-        assertEquals(false, StringUtils.isWhitespace("\t aa\n \t"));
-        assertEquals(true, StringUtils.isWhitespace(" "));
-        assertEquals(false, StringUtils.isWhitespace(" a "));
-        assertEquals(false, StringUtils.isWhitespace("a  "));
-        assertEquals(false, StringUtils.isWhitespace("  a"));
-        assertEquals(false, StringUtils.isWhitespace("aba"));
-        assertEquals(true, StringUtils.isWhitespace(StringUtilsTest.WHITESPACE));
-        assertEquals(false, StringUtils.isWhitespace(StringUtilsTest.NON_WHITESPACE));
+        assertFalse(StringUtils.isWhitespace(null));
+        assertTrue(StringUtils.isWhitespace(""));
+        assertTrue(StringUtils.isWhitespace(" "));
+        assertTrue(StringUtils.isWhitespace("\t \n \t"));
+        assertFalse(StringUtils.isWhitespace("\t aa\n \t"));
+        assertTrue(StringUtils.isWhitespace(" "));
+        assertFalse(StringUtils.isWhitespace(" a "));
+        assertFalse(StringUtils.isWhitespace("a  "));
+        assertFalse(StringUtils.isWhitespace("  a"));
+        assertFalse(StringUtils.isWhitespace("aba"));
+        assertTrue(StringUtils.isWhitespace(StringUtilsTest.WHITESPACE));
+        assertFalse(StringUtils.isWhitespace(StringUtilsTest.NON_WHITESPACE));
     }
 
     @Test
     public void testIsAlphaspace() {
-        assertEquals(false, StringUtils.isAlphaSpace(null));
-        assertEquals(true, StringUtils.isAlphaSpace(""));
-        assertEquals(true, StringUtils.isAlphaSpace(" "));
-        assertEquals(true, StringUtils.isAlphaSpace("a"));
-        assertEquals(true, StringUtils.isAlphaSpace("A"));
-        assertEquals(true, StringUtils.isAlphaSpace("kgKgKgKgkgkGkjkjlJlOKLgHdGdHgl"));
-        assertEquals(true, StringUtils.isAlphaSpace("ham kso"));
-        assertEquals(false, StringUtils.isAlphaSpace("1"));
-        assertEquals(false, StringUtils.isAlphaSpace("hkHKHik6iUGHKJgU7tUJgKJGI87GIkug"));
-        assertEquals(false, StringUtils.isAlphaSpace("_"));
-        assertEquals(false, StringUtils.isAlphaSpace("hkHKHik*khbkuh"));
+        assertFalse(StringUtils.isAlphaSpace(null));
+        assertTrue(StringUtils.isAlphaSpace(""));
+        assertTrue(StringUtils.isAlphaSpace(" "));
+        assertTrue(StringUtils.isAlphaSpace("a"));
+        assertTrue(StringUtils.isAlphaSpace("A"));
+        assertTrue(StringUtils.isAlphaSpace("kgKgKgKgkgkGkjkjlJlOKLgHdGdHgl"));
+        assertTrue(StringUtils.isAlphaSpace("ham kso"));
+        assertFalse(StringUtils.isAlphaSpace("1"));
+        assertFalse(StringUtils.isAlphaSpace("hkHKHik6iUGHKJgU7tUJgKJGI87GIkug"));
+        assertFalse(StringUtils.isAlphaSpace("_"));
+        assertFalse(StringUtils.isAlphaSpace("hkHKHik*khbkuh"));
     }
 
     @Test
     public void testIsAlphanumericSpace() {
-        assertEquals(false, StringUtils.isAlphanumericSpace(null));
-        assertEquals(true, StringUtils.isAlphanumericSpace(""));
-        assertEquals(true, StringUtils.isAlphanumericSpace(" "));
-        assertEquals(true, StringUtils.isAlphanumericSpace("a"));
-        assertEquals(true, StringUtils.isAlphanumericSpace("A"));
-        assertEquals(true, StringUtils.isAlphanumericSpace("kgKgKgKgkgkGkjkjlJlOKLgHdGdHgl"));
-        assertEquals(true, StringUtils.isAlphanumericSpace("ham kso"));
-        assertEquals(true, StringUtils.isAlphanumericSpace("1"));
-        assertEquals(true, StringUtils.isAlphanumericSpace("hkHKHik6iUGHKJgU7tUJgKJGI87GIkug"));
-        assertEquals(false, StringUtils.isAlphanumericSpace("_"));
-        assertEquals(false, StringUtils.isAlphanumericSpace("hkHKHik*khbkuh"));
+        assertFalse(StringUtils.isAlphanumericSpace(null));
+        assertTrue(StringUtils.isAlphanumericSpace(""));
+        assertTrue(StringUtils.isAlphanumericSpace(" "));
+        assertTrue(StringUtils.isAlphanumericSpace("a"));
+        assertTrue(StringUtils.isAlphanumericSpace("A"));
+        assertTrue(StringUtils.isAlphanumericSpace("kgKgKgKgkgkGkjkjlJlOKLgHdGdHgl"));
+        assertTrue(StringUtils.isAlphanumericSpace("ham kso"));
+        assertTrue(StringUtils.isAlphanumericSpace("1"));
+        assertTrue(StringUtils.isAlphanumericSpace("hkHKHik6iUGHKJgU7tUJgKJGI87GIkug"));
+        assertFalse(StringUtils.isAlphanumericSpace("_"));
+        assertFalse(StringUtils.isAlphanumericSpace("hkHKHik*khbkuh"));
     }
 
     @Test
     public void testIsAsciiPrintable_String() {
-        assertEquals(false, StringUtils.isAsciiPrintable(null));
-        assertEquals(true, StringUtils.isAsciiPrintable(""));
-        assertEquals(true, StringUtils.isAsciiPrintable(" "));
-        assertEquals(true, StringUtils.isAsciiPrintable("a"));
-        assertEquals(true, StringUtils.isAsciiPrintable("A"));
-        assertEquals(true, StringUtils.isAsciiPrintable("1"));
-        assertEquals(true, StringUtils.isAsciiPrintable("Ceki"));
-        assertEquals(true, StringUtils.isAsciiPrintable("!ab2c~"));
-        assertEquals(true, StringUtils.isAsciiPrintable("1000"));
-        assertEquals(true, StringUtils.isAsciiPrintable("10 00"));
-        assertEquals(false, StringUtils.isAsciiPrintable("10\t00"));
-        assertEquals(true, StringUtils.isAsciiPrintable("10.00"));
-        assertEquals(true, StringUtils.isAsciiPrintable("10,00"));
-        assertEquals(true, StringUtils.isAsciiPrintable("!ab-c~"));
-        assertEquals(true, StringUtils.isAsciiPrintable("hkHK=Hik6i?UGH_KJgU7.tUJgKJ*GI87GI,kug"));
-        assertEquals(true, StringUtils.isAsciiPrintable("\u0020"));
-        assertEquals(true, StringUtils.isAsciiPrintable("\u0021"));
-        assertEquals(true, StringUtils.isAsciiPrintable("\u007e"));
-        assertEquals(false, StringUtils.isAsciiPrintable("\u007f"));
-        assertEquals(true, StringUtils.isAsciiPrintable("G?lc?"));
-        assertEquals(true, StringUtils.isAsciiPrintable("=?iso-8859-1?Q?G=FClc=FC?="));
-        assertEquals(false, StringUtils.isAsciiPrintable("G\u00fclc\u00fc"));
+        assertFalse(StringUtils.isAsciiPrintable(null));
+        assertTrue(StringUtils.isAsciiPrintable(""));
+        assertTrue(StringUtils.isAsciiPrintable(" "));
+        assertTrue(StringUtils.isAsciiPrintable("a"));
+        assertTrue(StringUtils.isAsciiPrintable("A"));
+        assertTrue(StringUtils.isAsciiPrintable("1"));
+        assertTrue(StringUtils.isAsciiPrintable("Ceki"));
+        assertTrue(StringUtils.isAsciiPrintable("!ab2c~"));
+        assertTrue(StringUtils.isAsciiPrintable("1000"));
+        assertTrue(StringUtils.isAsciiPrintable("10 00"));
+        assertFalse(StringUtils.isAsciiPrintable("10\t00"));
+        assertTrue(StringUtils.isAsciiPrintable("10.00"));
+        assertTrue(StringUtils.isAsciiPrintable("10,00"));
+        assertTrue(StringUtils.isAsciiPrintable("!ab-c~"));
+        assertTrue(StringUtils.isAsciiPrintable("hkHK=Hik6i?UGH_KJgU7.tUJgKJ*GI87GI,kug"));
+        assertTrue(StringUtils.isAsciiPrintable("\u0020"));
+        assertTrue(StringUtils.isAsciiPrintable("\u0021"));
+        assertTrue(StringUtils.isAsciiPrintable("\u007e"));
+        assertFalse(StringUtils.isAsciiPrintable("\u007f"));
+        assertTrue(StringUtils.isAsciiPrintable("G?lc?"));
+        assertTrue(StringUtils.isAsciiPrintable("=?iso-8859-1?Q?G=FClc=FC?="));
+        assertFalse(StringUtils.isAsciiPrintable("G\u00fclc\u00fc"));
     }
   
     @Test
     public void testIsNumeric() {
-        assertEquals(false, StringUtils.isNumeric(null));
-        assertEquals(false, StringUtils.isNumeric(""));
-        assertEquals(false, StringUtils.isNumeric(" "));
-        assertEquals(false, StringUtils.isNumeric("a"));
-        assertEquals(false, StringUtils.isNumeric("A"));
-        assertEquals(false, StringUtils.isNumeric("kgKgKgKgkgkGkjkjlJlOKLgHdGdHgl"));
-        assertEquals(false, StringUtils.isNumeric("ham kso"));
-        assertEquals(true, StringUtils.isNumeric("1"));
-        assertEquals(true, StringUtils.isNumeric("1000"));
-        assertEquals(false, StringUtils.isNumeric("2.3"));
-        assertEquals(false, StringUtils.isNumeric("10 00"));
-        assertEquals(false, StringUtils.isNumeric("hkHKHik6iUGHKJgU7tUJgKJGI87GIkug"));
-        assertEquals(false, StringUtils.isNumeric("_"));
-        assertEquals(false, StringUtils.isNumeric("hkHKHik*khbkuh"));
-        assertEquals(false, StringUtils.isNumeric("+123"));
-        assertEquals(false, StringUtils.isNumeric("-123"));
+        assertFalse(StringUtils.isNumeric(null));
+        assertFalse(StringUtils.isNumeric(""));
+        assertFalse(StringUtils.isNumeric(" "));
+        assertFalse(StringUtils.isNumeric("a"));
+        assertFalse(StringUtils.isNumeric("A"));
+        assertFalse(StringUtils.isNumeric("kgKgKgKgkgkGkjkjlJlOKLgHdGdHgl"));
+        assertFalse(StringUtils.isNumeric("ham kso"));
+        assertTrue(StringUtils.isNumeric("1"));
+        assertTrue(StringUtils.isNumeric("1000"));
+        assertFalse(StringUtils.isNumeric("2.3"));
+        assertFalse(StringUtils.isNumeric("10 00"));
+        assertFalse(StringUtils.isNumeric("hkHKHik6iUGHKJgU7tUJgKJGI87GIkug"));
+        assertFalse(StringUtils.isNumeric("_"));
+        assertFalse(StringUtils.isNumeric("hkHKHik*khbkuh"));
+        assertFalse(StringUtils.isNumeric("+123"));
+        assertFalse(StringUtils.isNumeric("-123"));
     }
 
     @Test
     public void testIsNumericSpace() {
-        assertEquals(false, StringUtils.isNumericSpace(null));
-        assertEquals(true, StringUtils.isNumericSpace(""));
-        assertEquals(true, StringUtils.isNumericSpace(" "));
-        assertEquals(false, StringUtils.isNumericSpace("a"));
-        assertEquals(false, StringUtils.isNumericSpace("A"));
-        assertEquals(false, StringUtils.isNumericSpace("kgKgKgKgkgkGkjkjlJlOKLgHdGdHgl"));
-        assertEquals(false, StringUtils.isNumericSpace("ham kso"));
-        assertEquals(true, StringUtils.isNumericSpace("1"));
-        assertEquals(true, StringUtils.isNumericSpace("1000"));
-        assertEquals(false, StringUtils.isNumericSpace("2.3"));
-        assertEquals(true, StringUtils.isNumericSpace("10 00"));
-        assertEquals(false, StringUtils.isNumericSpace("hkHKHik6iUGHKJgU7tUJgKJGI87GIkug"));
-        assertEquals(false, StringUtils.isNumericSpace("_"));
-        assertEquals(false, StringUtils.isNumericSpace("hkHKHik*khbkuh"));
+        assertFalse(StringUtils.isNumericSpace(null));
+        assertTrue(StringUtils.isNumericSpace(""));
+        assertTrue(StringUtils.isNumericSpace(" "));
+        assertFalse(StringUtils.isNumericSpace("a"));
+        assertFalse(StringUtils.isNumericSpace("A"));
+        assertFalse(StringUtils.isNumericSpace("kgKgKgKgkgkGkjkjlJlOKLgHdGdHgl"));
+        assertFalse(StringUtils.isNumericSpace("ham kso"));
+        assertTrue(StringUtils.isNumericSpace("1"));
+        assertTrue(StringUtils.isNumericSpace("1000"));
+        assertFalse(StringUtils.isNumericSpace("2.3"));
+        assertTrue(StringUtils.isNumericSpace("10 00"));
+        assertFalse(StringUtils.isNumericSpace("hkHKHik6iUGHKJgU7tUJgKJGI87GIkug"));
+        assertFalse(StringUtils.isNumericSpace("_"));
+        assertFalse(StringUtils.isNumericSpace("hkHKHik*khbkuh"));
     }
 
 }

Modified: commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/StringUtilsTrimEmptyTest.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/StringUtilsTrimEmptyTest.java?rev=1387424&r1=1387423&r2=1387424&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/StringUtilsTrimEmptyTest.java (original)
+++ commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/StringUtilsTrimEmptyTest.java Wed Sep 19 01:29:22 2012
@@ -18,7 +18,9 @@ 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.assertNull;
+import static org.junit.Assert.assertTrue;
 
 import org.junit.Test;
 
@@ -33,38 +35,38 @@ public class StringUtilsTrimEmptyTest  {
     //-----------------------------------------------------------------------
     @Test
     public void testIsEmpty() {
-        assertEquals(true, StringUtils.isEmpty(null));
-        assertEquals(true, StringUtils.isEmpty(""));
-        assertEquals(false, StringUtils.isEmpty(" "));
-        assertEquals(false, StringUtils.isEmpty("foo"));
-        assertEquals(false, StringUtils.isEmpty("  foo  "));
+        assertTrue(StringUtils.isEmpty(null));
+        assertTrue(StringUtils.isEmpty(""));
+        assertFalse(StringUtils.isEmpty(" "));
+        assertFalse(StringUtils.isEmpty("foo"));
+        assertFalse(StringUtils.isEmpty("  foo  "));
     }
 
     @Test
     public void testIsNotEmpty() {
-        assertEquals(false, StringUtils.isNotEmpty(null));
-        assertEquals(false, StringUtils.isNotEmpty(""));
-        assertEquals(true, StringUtils.isNotEmpty(" "));
-        assertEquals(true, StringUtils.isNotEmpty("foo"));
-        assertEquals(true, StringUtils.isNotEmpty("  foo  "));
+        assertFalse(StringUtils.isNotEmpty(null));
+        assertFalse(StringUtils.isNotEmpty(""));
+        assertTrue(StringUtils.isNotEmpty(" "));
+        assertTrue(StringUtils.isNotEmpty("foo"));
+        assertTrue(StringUtils.isNotEmpty("  foo  "));
     }
 
     @Test
     public void testIsBlank() {
-        assertEquals(true, StringUtils.isBlank(null));
-        assertEquals(true, StringUtils.isBlank(""));
-        assertEquals(true, StringUtils.isBlank(StringUtilsTest.WHITESPACE));
-        assertEquals(false, StringUtils.isBlank("foo"));
-        assertEquals(false, StringUtils.isBlank("  foo  "));
+        assertTrue(StringUtils.isBlank(null));
+        assertTrue(StringUtils.isBlank(""));
+        assertTrue(StringUtils.isBlank(StringUtilsTest.WHITESPACE));
+        assertFalse(StringUtils.isBlank("foo"));
+        assertFalse(StringUtils.isBlank("  foo  "));
     }
 
     @Test
     public void testIsNotBlank() {
-        assertEquals(false, StringUtils.isNotBlank(null));
-        assertEquals(false, StringUtils.isNotBlank(""));
-        assertEquals(false, StringUtils.isNotBlank(StringUtilsTest.WHITESPACE));
-        assertEquals(true, StringUtils.isNotBlank("foo"));
-        assertEquals(true, StringUtils.isNotBlank("  foo  "));
+        assertFalse(StringUtils.isNotBlank(null));
+        assertFalse(StringUtils.isNotBlank(""));
+        assertFalse(StringUtils.isNotBlank(StringUtilsTest.WHITESPACE));
+        assertTrue(StringUtils.isNotBlank("foo"));
+        assertTrue(StringUtils.isNotBlank("  foo  "));
     }
 
     //-----------------------------------------------------------------------

Modified: commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/SystemUtilsTest.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/SystemUtilsTest.java?rev=1387424&r1=1387423&r2=1387424&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/SystemUtilsTest.java (original)
+++ commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/SystemUtilsTest.java Wed Sep 19 01:29:22 2012
@@ -44,9 +44,9 @@ public class SystemUtilsTest {
         assertNotNull(new SystemUtils());
         Constructor<?>[] cons = SystemUtils.class.getDeclaredConstructors();
         assertEquals(1, cons.length);
-        assertEquals(true, Modifier.isPublic(cons[0].getModifiers()));
-        assertEquals(true, Modifier.isPublic(SystemUtils.class.getModifiers()));
-        assertEquals(false, Modifier.isFinal(SystemUtils.class.getModifiers()));
+        assertTrue(Modifier.isPublic(cons[0].getModifiers()));
+        assertTrue(Modifier.isPublic(SystemUtils.class.getModifiers()));
+        assertFalse(Modifier.isFinal(SystemUtils.class.getModifiers()));
     }
 
     /**
@@ -93,61 +93,61 @@ public class SystemUtilsTest {
     public void testIS_JAVA() {
         String javaVersion = System.getProperty("java.version");
         if (javaVersion == null) {
-            assertEquals(false, SystemUtils.IS_JAVA_1_1);
-            assertEquals(false, SystemUtils.IS_JAVA_1_2);
-            assertEquals(false, SystemUtils.IS_JAVA_1_3);
-            assertEquals(false, SystemUtils.IS_JAVA_1_4);
-            assertEquals(false, SystemUtils.IS_JAVA_1_5);
-            assertEquals(false, SystemUtils.IS_JAVA_1_6);
-            assertEquals(false, SystemUtils.IS_JAVA_1_7);
+            assertFalse(SystemUtils.IS_JAVA_1_1);
+            assertFalse(SystemUtils.IS_JAVA_1_2);
+            assertFalse(SystemUtils.IS_JAVA_1_3);
+            assertFalse(SystemUtils.IS_JAVA_1_4);
+            assertFalse(SystemUtils.IS_JAVA_1_5);
+            assertFalse(SystemUtils.IS_JAVA_1_6);
+            assertFalse(SystemUtils.IS_JAVA_1_7);
         } else if (javaVersion.startsWith("1.1")) {
-            assertEquals(true, SystemUtils.IS_JAVA_1_1);
-            assertEquals(false, SystemUtils.IS_JAVA_1_2);
-            assertEquals(false, SystemUtils.IS_JAVA_1_3);
-            assertEquals(false, SystemUtils.IS_JAVA_1_4);
-            assertEquals(false, SystemUtils.IS_JAVA_1_5);
-            assertEquals(false, SystemUtils.IS_JAVA_1_6);
-            assertEquals(false, SystemUtils.IS_JAVA_1_7);
+            assertTrue(SystemUtils.IS_JAVA_1_1);
+            assertFalse(SystemUtils.IS_JAVA_1_2);
+            assertFalse(SystemUtils.IS_JAVA_1_3);
+            assertFalse(SystemUtils.IS_JAVA_1_4);
+            assertFalse(SystemUtils.IS_JAVA_1_5);
+            assertFalse(SystemUtils.IS_JAVA_1_6);
+            assertFalse(SystemUtils.IS_JAVA_1_7);
         } else if (javaVersion.startsWith("1.2")) {
-            assertEquals(false, SystemUtils.IS_JAVA_1_1);
-            assertEquals(true, SystemUtils.IS_JAVA_1_2);
-            assertEquals(false, SystemUtils.IS_JAVA_1_3);
-            assertEquals(false, SystemUtils.IS_JAVA_1_4);
-            assertEquals(false, SystemUtils.IS_JAVA_1_5);
-            assertEquals(false, SystemUtils.IS_JAVA_1_6);
-            assertEquals(false, SystemUtils.IS_JAVA_1_7);
+            assertFalse(SystemUtils.IS_JAVA_1_1);
+            assertTrue(SystemUtils.IS_JAVA_1_2);
+            assertFalse(SystemUtils.IS_JAVA_1_3);
+            assertFalse(SystemUtils.IS_JAVA_1_4);
+            assertFalse(SystemUtils.IS_JAVA_1_5);
+            assertFalse(SystemUtils.IS_JAVA_1_6);
+            assertFalse(SystemUtils.IS_JAVA_1_7);
         } else if (javaVersion.startsWith("1.3")) {
-            assertEquals(false, SystemUtils.IS_JAVA_1_1);
-            assertEquals(false, SystemUtils.IS_JAVA_1_2);
-            assertEquals(true, SystemUtils.IS_JAVA_1_3);
-            assertEquals(false, SystemUtils.IS_JAVA_1_4);
-            assertEquals(false, SystemUtils.IS_JAVA_1_5);
-            assertEquals(false, SystemUtils.IS_JAVA_1_6);
-            assertEquals(false, SystemUtils.IS_JAVA_1_7);
+            assertFalse(SystemUtils.IS_JAVA_1_1);
+            assertFalse(SystemUtils.IS_JAVA_1_2);
+            assertTrue(SystemUtils.IS_JAVA_1_3);
+            assertFalse(SystemUtils.IS_JAVA_1_4);
+            assertFalse(SystemUtils.IS_JAVA_1_5);
+            assertFalse(SystemUtils.IS_JAVA_1_6);
+            assertFalse(SystemUtils.IS_JAVA_1_7);
         } else if (javaVersion.startsWith("1.4")) {
-            assertEquals(false, SystemUtils.IS_JAVA_1_1);
-            assertEquals(false, SystemUtils.IS_JAVA_1_2);
-            assertEquals(false, SystemUtils.IS_JAVA_1_3);
-            assertEquals(true, SystemUtils.IS_JAVA_1_4);
-            assertEquals(false, SystemUtils.IS_JAVA_1_5);
-            assertEquals(false, SystemUtils.IS_JAVA_1_6);
-            assertEquals(false, SystemUtils.IS_JAVA_1_7);
+            assertFalse(SystemUtils.IS_JAVA_1_1);
+            assertFalse(SystemUtils.IS_JAVA_1_2);
+            assertFalse(SystemUtils.IS_JAVA_1_3);
+            assertTrue(SystemUtils.IS_JAVA_1_4);
+            assertFalse(SystemUtils.IS_JAVA_1_5);
+            assertFalse(SystemUtils.IS_JAVA_1_6);
+            assertFalse(SystemUtils.IS_JAVA_1_7);
         } else if (javaVersion.startsWith("1.5")) {
-            assertEquals(false, SystemUtils.IS_JAVA_1_1);
-            assertEquals(false, SystemUtils.IS_JAVA_1_2);
-            assertEquals(false, SystemUtils.IS_JAVA_1_3);
-            assertEquals(false, SystemUtils.IS_JAVA_1_4);
-            assertEquals(true, SystemUtils.IS_JAVA_1_5);
-            assertEquals(false, SystemUtils.IS_JAVA_1_6);
-            assertEquals(false, SystemUtils.IS_JAVA_1_7);
+            assertFalse(SystemUtils.IS_JAVA_1_1);
+            assertFalse(SystemUtils.IS_JAVA_1_2);
+            assertFalse(SystemUtils.IS_JAVA_1_3);
+            assertFalse(SystemUtils.IS_JAVA_1_4);
+            assertTrue(SystemUtils.IS_JAVA_1_5);
+            assertFalse(SystemUtils.IS_JAVA_1_6);
+            assertFalse(SystemUtils.IS_JAVA_1_7);
         } else if (javaVersion.startsWith("1.6")) {
-            assertEquals(false, SystemUtils.IS_JAVA_1_1);
-            assertEquals(false, SystemUtils.IS_JAVA_1_2);
-            assertEquals(false, SystemUtils.IS_JAVA_1_3);
-            assertEquals(false, SystemUtils.IS_JAVA_1_4);
-            assertEquals(false, SystemUtils.IS_JAVA_1_5);
-            assertEquals(true, SystemUtils.IS_JAVA_1_6);
-            assertEquals(false, SystemUtils.IS_JAVA_1_7);
+            assertFalse(SystemUtils.IS_JAVA_1_1);
+            assertFalse(SystemUtils.IS_JAVA_1_2);
+            assertFalse(SystemUtils.IS_JAVA_1_3);
+            assertFalse(SystemUtils.IS_JAVA_1_4);
+            assertFalse(SystemUtils.IS_JAVA_1_5);
+            assertTrue(SystemUtils.IS_JAVA_1_6);
+            assertFalse(SystemUtils.IS_JAVA_1_7);
         } else {
             System.out.println("Can't test IS_JAVA value");
         }
@@ -157,34 +157,34 @@ public class SystemUtilsTest {
     public void testIS_OS() {
         String osName = System.getProperty("os.name");
         if (osName == null) {
-            assertEquals(false, SystemUtils.IS_OS_WINDOWS);
-            assertEquals(false, SystemUtils.IS_OS_UNIX);
-            assertEquals(false, SystemUtils.IS_OS_SOLARIS);
-            assertEquals(false, SystemUtils.IS_OS_LINUX);
-            assertEquals(false, SystemUtils.IS_OS_MAC_OSX);
+            assertFalse(SystemUtils.IS_OS_WINDOWS);
+            assertFalse(SystemUtils.IS_OS_UNIX);
+            assertFalse(SystemUtils.IS_OS_SOLARIS);
+            assertFalse(SystemUtils.IS_OS_LINUX);
+            assertFalse(SystemUtils.IS_OS_MAC_OSX);
         } else if (osName.startsWith("Windows")) {
-            assertEquals(false, SystemUtils.IS_OS_UNIX);
-            assertEquals(true, SystemUtils.IS_OS_WINDOWS);
+            assertFalse(SystemUtils.IS_OS_UNIX);
+            assertTrue(SystemUtils.IS_OS_WINDOWS);
         } else if (osName.startsWith("Solaris")) {
-            assertEquals(true, SystemUtils.IS_OS_SOLARIS);
-            assertEquals(true, SystemUtils.IS_OS_UNIX);
-            assertEquals(false, SystemUtils.IS_OS_WINDOWS);
+            assertTrue(SystemUtils.IS_OS_SOLARIS);
+            assertTrue(SystemUtils.IS_OS_UNIX);
+            assertFalse(SystemUtils.IS_OS_WINDOWS);
         } else if (osName.toLowerCase(Locale.ENGLISH).startsWith("linux")) {
-            assertEquals(true, SystemUtils.IS_OS_LINUX);
-            assertEquals(true, SystemUtils.IS_OS_UNIX);
-            assertEquals(false, SystemUtils.IS_OS_WINDOWS);
+            assertTrue(SystemUtils.IS_OS_LINUX);
+            assertTrue(SystemUtils.IS_OS_UNIX);
+            assertFalse(SystemUtils.IS_OS_WINDOWS);
         } else if (osName.startsWith("Mac OS X")) {
-            assertEquals(true, SystemUtils.IS_OS_MAC_OSX);
-            assertEquals(true, SystemUtils.IS_OS_UNIX);
-            assertEquals(false, SystemUtils.IS_OS_WINDOWS);
+            assertTrue(SystemUtils.IS_OS_MAC_OSX);
+            assertTrue(SystemUtils.IS_OS_UNIX);
+            assertFalse(SystemUtils.IS_OS_WINDOWS);
         } else if (osName.startsWith("OS/2")) {
-            assertEquals(true, SystemUtils.IS_OS_OS2);
-            assertEquals(false, SystemUtils.IS_OS_UNIX);
-            assertEquals(false, SystemUtils.IS_OS_WINDOWS);
+            assertTrue(SystemUtils.IS_OS_OS2);
+            assertFalse(SystemUtils.IS_OS_UNIX);
+            assertFalse(SystemUtils.IS_OS_WINDOWS);
         } else if (osName.startsWith("SunOS")) {
-            assertEquals(true, SystemUtils.IS_OS_SUN_OS);
-            assertEquals(true, SystemUtils.IS_OS_UNIX);
-            assertEquals(false, SystemUtils.IS_OS_WINDOWS);
+            assertTrue(SystemUtils.IS_OS_SUN_OS);
+            assertTrue(SystemUtils.IS_OS_UNIX);
+            assertFalse(SystemUtils.IS_OS_WINDOWS);
         } else {
             System.out.println("Can't test IS_OS value");
         }
@@ -193,161 +193,161 @@ public class SystemUtilsTest {
     @Test
     public void testJavaVersionMatches() {
         String javaVersion = null;
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
         javaVersion = "";
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
         javaVersion = "1.0";
-        assertEquals(true, SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
+        assertTrue(SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
         javaVersion = "1.1";
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
-        assertEquals(true, SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
+        assertTrue(SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
         javaVersion = "1.2";
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
-        assertEquals(true, SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
+        assertTrue(SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
         javaVersion = "1.3.0";
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
-        assertEquals(true, SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
+        assertTrue(SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
         javaVersion = "1.3.1";
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
-        assertEquals(true, SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
+        assertTrue(SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
         javaVersion = "1.4.0";
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
-        assertEquals(true, SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
+        assertTrue(SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
         javaVersion = "1.4.1";
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
-        assertEquals(true, SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
+        assertTrue(SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
         javaVersion = "1.4.2";
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
-        assertEquals(true, SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
+        assertTrue(SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
         javaVersion = "1.5.0";
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
-        assertEquals(true, SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
+        assertTrue(SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
         javaVersion = "1.6.0";
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
-        assertEquals(true, SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
+        assertTrue(SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
         javaVersion = "1.7.0";
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
-        assertEquals(false, SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
-        assertEquals(true, SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.0"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.1"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.2"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.3"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.4"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.5"));
+        assertFalse(SystemUtils.isJavaVersionMatch(javaVersion, "1.6"));
+        assertTrue(SystemUtils.isJavaVersionMatch(javaVersion, "1.7"));
     }
 
     @Test
     public void testOSMatchesName() {
         String osName = null;
-        assertEquals(false, SystemUtils.isOSNameMatch(osName, "Windows"));
+        assertFalse(SystemUtils.isOSNameMatch(osName, "Windows"));
         osName = "";
-        assertEquals(false, SystemUtils.isOSNameMatch(osName, "Windows"));
+        assertFalse(SystemUtils.isOSNameMatch(osName, "Windows"));
         osName = "Windows 95";
-        assertEquals(true, SystemUtils.isOSNameMatch(osName, "Windows"));
+        assertTrue(SystemUtils.isOSNameMatch(osName, "Windows"));
         osName = "Windows NT";
-        assertEquals(true, SystemUtils.isOSNameMatch(osName, "Windows"));
+        assertTrue(SystemUtils.isOSNameMatch(osName, "Windows"));
         osName = "OS/2";
-        assertEquals(false, SystemUtils.isOSNameMatch(osName, "Windows"));
+        assertFalse(SystemUtils.isOSNameMatch(osName, "Windows"));
     }
 
     @Test
     public void testOSMatchesNameAndVersion() {
         String osName = null;
         String osVersion = null;
-        assertEquals(false, SystemUtils.isOSMatch(osName, osVersion, "Windows 9", "4.1"));
+        assertFalse(SystemUtils.isOSMatch(osName, osVersion, "Windows 9", "4.1"));
         osName = "";
         osVersion = "";
-        assertEquals(false, SystemUtils.isOSMatch(osName, osVersion, "Windows 9", "4.1"));
+        assertFalse(SystemUtils.isOSMatch(osName, osVersion, "Windows 9", "4.1"));
         osName = "Windows 95";
         osVersion = "4.0";
-        assertEquals(false, SystemUtils.isOSMatch(osName, osVersion, "Windows 9", "4.1"));
+        assertFalse(SystemUtils.isOSMatch(osName, osVersion, "Windows 9", "4.1"));
         osName = "Windows 95";
         osVersion = "4.1";
-        assertEquals(true, SystemUtils.isOSMatch(osName, osVersion, "Windows 9", "4.1"));
+        assertTrue(SystemUtils.isOSMatch(osName, osVersion, "Windows 9", "4.1"));
         osName = "Windows 98";
         osVersion = "4.1";
-        assertEquals(true, SystemUtils.isOSMatch(osName, osVersion, "Windows 9", "4.1"));
+        assertTrue(SystemUtils.isOSMatch(osName, osVersion, "Windows 9", "4.1"));
         osName = "Windows NT";
         osVersion = "4.0";
-        assertEquals(false, SystemUtils.isOSMatch(osName, osVersion, "Windows 9", "4.1"));
+        assertFalse(SystemUtils.isOSMatch(osName, osVersion, "Windows 9", "4.1"));
         osName = "OS/2";
         osVersion = "4.0";
-        assertEquals(false, SystemUtils.isOSMatch(osName, osVersion, "Windows 9", "4.1"));
+        assertFalse(SystemUtils.isOSMatch(osName, osVersion, "Windows 9", "4.1"));
     }
 
     @Test

Modified: commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/ValidateTest.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/ValidateTest.java?rev=1387424&r1=1387423&r2=1387424&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/ValidateTest.java (original)
+++ commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/ValidateTest.java Wed Sep 19 01:29:22 2012
@@ -19,8 +19,10 @@
 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 java.lang.reflect.Constructor;
@@ -644,9 +646,9 @@ public class ValidateTest  {
         assertNotNull(new Validate());
         Constructor<?>[] cons = Validate.class.getDeclaredConstructors();
         assertEquals(1, cons.length);
-        assertEquals(true, Modifier.isPublic(cons[0].getModifiers()));
-        assertEquals(true, Modifier.isPublic(Validate.class.getModifiers()));
-        assertEquals(false, Modifier.isFinal(Validate.class.getModifiers()));
+        assertTrue(Modifier.isPublic(cons[0].getModifiers()));
+        assertTrue(Modifier.isPublic(Validate.class.getModifiers()));
+        assertFalse(Modifier.isFinal(Validate.class.getModifiers()));
     }
 
     //-----------------------------------------------------------------------

Modified: commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/exception/ExceptionUtilsTest.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/exception/ExceptionUtilsTest.java?rev=1387424&r1=1387423&r2=1387424&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/exception/ExceptionUtilsTest.java (original)
+++ commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/exception/ExceptionUtilsTest.java Wed Sep 19 01:29:22 2012
@@ -108,9 +108,9 @@ public class ExceptionUtilsTest {
         assertNotNull(new ExceptionUtils());
         Constructor<?>[] cons = ExceptionUtils.class.getDeclaredConstructors();
         assertEquals(1, cons.length);
-        assertEquals(true, Modifier.isPublic(cons[0].getModifiers()));
-        assertEquals(true, Modifier.isPublic(ExceptionUtils.class.getModifiers()));
-        assertEquals(false, Modifier.isFinal(ExceptionUtils.class.getModifiers()));
+        assertTrue(Modifier.isPublic(cons[0].getModifiers()));
+        assertTrue(Modifier.isPublic(ExceptionUtils.class.getModifiers()));
+        assertFalse(Modifier.isFinal(ExceptionUtils.class.getModifiers()));
     }
     
     //-----------------------------------------------------------------------
@@ -439,7 +439,7 @@ public class ExceptionUtilsTest {
                 break;
             }
         }
-        assertEquals(true, match);
+        assertTrue(match);
         
         stackTrace = ExceptionUtils.getRootCauseStackTrace(withoutCause);
         match = false;
@@ -449,7 +449,7 @@ public class ExceptionUtilsTest {
                 break;
             }
         }
-        assertEquals(false, match);
+        assertFalse(match);
     }
 
     @Test

Modified: commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/math/FractionTest.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/math/FractionTest.java?rev=1387424&r1=1387423&r2=1387424&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/math/FractionTest.java (original)
+++ commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/math/FractionTest.java Wed Sep 19 01:29:22 2012
@@ -1240,21 +1240,21 @@ public class FractionTest  {
         Fraction f2 = null;
         
         f1 = Fraction.getFraction(3, 5);
-        assertEquals(false, f1.equals(null));
-        assertEquals(false, f1.equals(new Object()));
-        assertEquals(false, f1.equals(Integer.valueOf(6)));
+        assertFalse(f1.equals(null));
+        assertFalse(f1.equals(new Object()));
+        assertFalse(f1.equals(Integer.valueOf(6)));
         
         f1 = Fraction.getFraction(3, 5);
         f2 = Fraction.getFraction(2, 5);
-        assertEquals(false, f1.equals(f2));
-        assertEquals(true, f1.equals(f1));
-        assertEquals(true, f2.equals(f2));
+        assertFalse(f1.equals(f2));
+        assertTrue(f1.equals(f1));
+        assertTrue(f2.equals(f2));
         
         f2 = Fraction.getFraction(3, 5);
-        assertEquals(true, f1.equals(f2));
+        assertTrue(f1.equals(f2));
         
         f2 = Fraction.getFraction(6, 10);
-        assertEquals(false, f1.equals(f2));
+        assertFalse(f1.equals(f2));
     }
     
     @Test

Modified: commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableByteTest.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableByteTest.java?rev=1387424&r1=1387423&r2=1387424&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableByteTest.java (original)
+++ commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableByteTest.java Wed Sep 19 01:29:22 2012
@@ -74,16 +74,16 @@ public class MutableByteTest {
         final MutableByte mutNumB = new MutableByte((byte) 0);
         final MutableByte mutNumC = new MutableByte((byte) 1);
 
-        assertEquals(true, mutNumA.equals(mutNumA));
-        assertEquals(true, mutNumA.equals(mutNumB));
-        assertEquals(true, mutNumB.equals(mutNumA));
-        assertEquals(true, mutNumB.equals(mutNumB));
-        assertEquals(false, mutNumA.equals(mutNumC));
-        assertEquals(false, mutNumB.equals(mutNumC));
-        assertEquals(true, mutNumC.equals(mutNumC));
-        assertEquals(false, mutNumA.equals(null));
-        assertEquals(false, mutNumA.equals(Byte.valueOf((byte) 0)));
-        assertEquals(false, mutNumA.equals("0"));
+        assertTrue(mutNumA.equals(mutNumA));
+        assertTrue(mutNumA.equals(mutNumB));
+        assertTrue(mutNumB.equals(mutNumA));
+        assertTrue(mutNumB.equals(mutNumB));
+        assertFalse(mutNumA.equals(mutNumC));
+        assertFalse(mutNumB.equals(mutNumC));
+        assertTrue(mutNumC.equals(mutNumC));
+        assertFalse(mutNumA.equals(null));
+        assertFalse(mutNumA.equals(Byte.valueOf((byte) 0)));
+        assertFalse(mutNumA.equals("0"));
     }
 
     @Test

Modified: commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableDoubleTest.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableDoubleTest.java?rev=1387424&r1=1387423&r2=1387424&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableDoubleTest.java (original)
+++ commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableDoubleTest.java Wed Sep 19 01:29:22 2012
@@ -71,13 +71,13 @@ public class MutableDoubleTest {
     @Test
     public void testNanInfinite() {
         MutableDouble mutNum = new MutableDouble(Double.NaN);
-        assertEquals(true, mutNum.isNaN());
+        assertTrue(mutNum.isNaN());
         
         mutNum = new MutableDouble(Double.POSITIVE_INFINITY);
-        assertEquals(true, mutNum.isInfinite());
+        assertTrue(mutNum.isInfinite());
         
         mutNum = new MutableDouble(Double.NEGATIVE_INFINITY);
-        assertEquals(true, mutNum.isInfinite());
+        assertTrue(mutNum.isInfinite());
     }
 
     @Test
@@ -86,16 +86,16 @@ public class MutableDoubleTest {
         final MutableDouble mutNumB = new MutableDouble(0d);
         final MutableDouble mutNumC = new MutableDouble(1d);
 
-        assertEquals(true, mutNumA.equals(mutNumA));
-        assertEquals(true, mutNumA.equals(mutNumB));
-        assertEquals(true, mutNumB.equals(mutNumA));
-        assertEquals(true, mutNumB.equals(mutNumB));
-        assertEquals(false, mutNumA.equals(mutNumC));
-        assertEquals(false, mutNumB.equals(mutNumC));
-        assertEquals(true, mutNumC.equals(mutNumC));
-        assertEquals(false, mutNumA.equals(null));
-        assertEquals(false, mutNumA.equals(Double.valueOf(0d)));
-        assertEquals(false, mutNumA.equals("0"));
+        assertTrue(mutNumA.equals(mutNumA));
+        assertTrue(mutNumA.equals(mutNumB));
+        assertTrue(mutNumB.equals(mutNumA));
+        assertTrue(mutNumB.equals(mutNumB));
+        assertFalse(mutNumA.equals(mutNumC));
+        assertFalse(mutNumB.equals(mutNumC));
+        assertTrue(mutNumC.equals(mutNumC));
+        assertFalse(mutNumA.equals(null));
+        assertFalse(mutNumA.equals(Double.valueOf(0d)));
+        assertFalse(mutNumA.equals("0"));
     }
 
     @Test

Modified: commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableFloatTest.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableFloatTest.java?rev=1387424&r1=1387423&r2=1387424&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableFloatTest.java (original)
+++ commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableFloatTest.java Wed Sep 19 01:29:22 2012
@@ -71,13 +71,13 @@ public class MutableFloatTest {
     @Test
     public void testNanInfinite() {
         MutableFloat mutNum = new MutableFloat(Float.NaN);
-        assertEquals(true, mutNum.isNaN());
+        assertTrue(mutNum.isNaN());
         
         mutNum = new MutableFloat(Float.POSITIVE_INFINITY);
-        assertEquals(true, mutNum.isInfinite());
+        assertTrue(mutNum.isInfinite());
         
         mutNum = new MutableFloat(Float.NEGATIVE_INFINITY);
-        assertEquals(true, mutNum.isInfinite());
+        assertTrue(mutNum.isInfinite());
     }
 
     @Test
@@ -86,16 +86,16 @@ public class MutableFloatTest {
         final MutableFloat mutNumB = new MutableFloat(0f);
         final MutableFloat mutNumC = new MutableFloat(1f);
 
-        assertEquals(true, mutNumA.equals(mutNumA));
-        assertEquals(true, mutNumA.equals(mutNumB));
-        assertEquals(true, mutNumB.equals(mutNumA));
-        assertEquals(true, mutNumB.equals(mutNumB));
-        assertEquals(false, mutNumA.equals(mutNumC));
-        assertEquals(false, mutNumB.equals(mutNumC));
-        assertEquals(true, mutNumC.equals(mutNumC));
-        assertEquals(false, mutNumA.equals(null));
-        assertEquals(false, mutNumA.equals(Float.valueOf(0f)));
-        assertEquals(false, mutNumA.equals("0"));
+        assertTrue(mutNumA.equals(mutNumA));
+        assertTrue(mutNumA.equals(mutNumB));
+        assertTrue(mutNumB.equals(mutNumA));
+        assertTrue(mutNumB.equals(mutNumB));
+        assertFalse(mutNumA.equals(mutNumC));
+        assertFalse(mutNumB.equals(mutNumC));
+        assertTrue(mutNumC.equals(mutNumC));
+        assertFalse(mutNumA.equals(null));
+        assertFalse(mutNumA.equals(Float.valueOf(0f)));
+        assertFalse(mutNumA.equals("0"));
     }
 
     @Test

Modified: commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableIntTest.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableIntTest.java?rev=1387424&r1=1387423&r2=1387424&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableIntTest.java (original)
+++ commons/proper/lang/trunk/src/test/java/org/apache/commons/lang3/mutable/MutableIntTest.java Wed Sep 19 01:29:22 2012
@@ -81,16 +81,16 @@ public class MutableIntTest {
      * @param numC must not equal numA; must not equal numC.
      */
     void testEquals(final Number numA, final Number numB, final Number numC) {
-        assertEquals(true, numA.equals(numA));
-        assertEquals(true, numA.equals(numB));
-        assertEquals(true, numB.equals(numA));
-        assertEquals(true, numB.equals(numB));
-        assertEquals(false, numA.equals(numC));
-        assertEquals(false, numB.equals(numC));
-        assertEquals(true, numC.equals(numC));
-        assertEquals(false, numA.equals(null));
-        assertEquals(false, numA.equals(Integer.valueOf(0)));
-        assertEquals(false, numA.equals("0"));
+        assertTrue(numA.equals(numA));
+        assertTrue(numA.equals(numB));
+        assertTrue(numB.equals(numA));
+        assertTrue(numB.equals(numB));
+        assertFalse(numA.equals(numC));
+        assertFalse(numB.equals(numC));
+        assertTrue(numC.equals(numC));
+        assertFalse(numA.equals(null));
+        assertFalse(numA.equals(Integer.valueOf(0)));
+        assertFalse(numA.equals("0"));
     }
 
     @Test



Mime
View raw message