commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From brit...@apache.org
Subject [22/48] [lang] Make sure lines in files don't have trailing white spaces and remove all trailing white spaces
Date Thu, 08 Jun 2017 08:15:56 GMT
http://git-wip-us.apache.org/repos/asf/commons-lang/blob/1da8ccdb/src/test/java/org/apache/commons/lang3/BooleanUtilsTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/lang3/BooleanUtilsTest.java b/src/test/java/org/apache/commons/lang3/BooleanUtilsTest.java
index b16a2e0..5d22dad 100644
--- a/src/test/java/org/apache/commons/lang3/BooleanUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/BooleanUtilsTest.java
@@ -5,9 +5,9 @@
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -42,7 +42,7 @@ public class BooleanUtilsTest {
         assertTrue(Modifier.isPublic(BooleanUtils.class.getModifiers()));
         assertFalse(Modifier.isFinal(BooleanUtils.class.getModifiers()));
     }
-    
+
     //-----------------------------------------------------------------------
     @Test
     public void test_negate_Boolean() {
@@ -107,14 +107,14 @@ public class BooleanUtilsTest {
         assertTrue(BooleanUtils.toBoolean(-1));
         assertFalse(BooleanUtils.toBoolean(0));
     }
-    
+
     @Test
     public void test_toBooleanObject_int() {
         assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject(1));
         assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject(-1));
         assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject(0));
     }
-    
+
     @Test
     public void test_toBooleanObject_Integer() {
         assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject(Integer.valueOf(1)));
@@ -122,7 +122,7 @@ public class BooleanUtilsTest {
         assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject(Integer.valueOf(0)));
         assertEquals(null, BooleanUtils.toBooleanObject((Integer) null));
     }
-    
+
     //-----------------------------------------------------------------------
     @Test
     public void test_toBoolean_int_int_int() {
@@ -134,7 +134,7 @@ public class BooleanUtilsTest {
     public void test_toBoolean_int_int_int_noMatch() {
         BooleanUtils.toBoolean(8, 6, 7);
     }
-    
+
     @Test
     public void test_toBoolean_Integer_Integer_Integer() {
         final Integer six = Integer.valueOf(6);
@@ -156,7 +156,7 @@ public class BooleanUtilsTest {
     public void test_toBoolean_Integer_Integer_Integer_noMatch() {
         BooleanUtils.toBoolean(Integer.valueOf(8), Integer.valueOf(6), Integer.valueOf(7));
     }
-    
+
     //-----------------------------------------------------------------------
     @Test
     public void test_toBooleanObject_int_int_int() {
@@ -169,7 +169,7 @@ public class BooleanUtilsTest {
     public void test_toBooleanObject_int_int_int_noMatch() {
         BooleanUtils.toBooleanObject(9, 6, 7, 8);
     }
-    
+
     @Test
     public void test_toBooleanObject_Integer_Integer_Integer_Integer() {
         final Integer six = Integer.valueOf(6);
@@ -201,34 +201,34 @@ public class BooleanUtilsTest {
         assertEquals(1, BooleanUtils.toInteger(true));
         assertEquals(0, BooleanUtils.toInteger(false));
     }
-    
+
     @Test
     public void test_toIntegerObject_boolean() {
         assertEquals(Integer.valueOf(1), BooleanUtils.toIntegerObject(true));
         assertEquals(Integer.valueOf(0), BooleanUtils.toIntegerObject(false));
     }
-    
+
     @Test
     public void test_toIntegerObject_Boolean() {
         assertEquals(Integer.valueOf(1), BooleanUtils.toIntegerObject(Boolean.TRUE));
         assertEquals(Integer.valueOf(0), BooleanUtils.toIntegerObject(Boolean.FALSE));
         assertEquals(null, BooleanUtils.toIntegerObject(null));
     }
-    
+
     //-----------------------------------------------------------------------
     @Test
     public void test_toInteger_boolean_int_int() {
         assertEquals(6, BooleanUtils.toInteger(true, 6, 7));
         assertEquals(7, BooleanUtils.toInteger(false, 6, 7));
     }
-    
+
     @Test
     public void test_toInteger_Boolean_int_int_int() {
         assertEquals(6, BooleanUtils.toInteger(Boolean.TRUE, 6, 7, 8));
         assertEquals(7, BooleanUtils.toInteger(Boolean.FALSE, 6, 7, 8));
         assertEquals(8, BooleanUtils.toInteger(null, 6, 7, 8));
     }
-    
+
     @Test
     public void test_toIntegerObject_boolean_Integer_Integer() {
         final Integer six = Integer.valueOf(6);
@@ -236,7 +236,7 @@ public class BooleanUtilsTest {
         assertEquals(six, BooleanUtils.toIntegerObject(true, six, seven));
         assertEquals(seven, BooleanUtils.toIntegerObject(false, six, seven));
     }
-    
+
     @Test
     public void test_toIntegerObject_Boolean_Integer_Integer_Integer() {
         final Integer six = Integer.valueOf(6);
@@ -247,7 +247,7 @@ public class BooleanUtilsTest {
         assertEquals(eight, BooleanUtils.toIntegerObject(null, six, seven, eight));
         assertEquals(null, BooleanUtils.toIntegerObject(null, six, seven, null));
     }
-    
+
     //-----------------------------------------------------------------------
     //-----------------------------------------------------------------------
     @Test
@@ -285,7 +285,7 @@ public class BooleanUtilsTest {
         assertEquals(null, BooleanUtils.toBooleanObject("true "));
         assertEquals(null, BooleanUtils.toBooleanObject("ono"));
     }
-    
+
     @Test
     public void test_toBooleanObject_String_String_String_String() {
         assertSame(Boolean.TRUE, BooleanUtils.toBooleanObject(null, null, "N", "U"));
@@ -385,53 +385,53 @@ public class BooleanUtilsTest {
         assertEquals("true", BooleanUtils.toStringTrueFalse(Boolean.TRUE));
         assertEquals("false", BooleanUtils.toStringTrueFalse(Boolean.FALSE));
     }
-    
+
     @Test
     public void test_toStringOnOff_Boolean() {
         assertEquals(null, BooleanUtils.toStringOnOff(null));
         assertEquals("on", BooleanUtils.toStringOnOff(Boolean.TRUE));
         assertEquals("off", BooleanUtils.toStringOnOff(Boolean.FALSE));
     }
-    
+
     @Test
     public void test_toStringYesNo_Boolean() {
         assertEquals(null, BooleanUtils.toStringYesNo(null));
         assertEquals("yes", BooleanUtils.toStringYesNo(Boolean.TRUE));
         assertEquals("no", BooleanUtils.toStringYesNo(Boolean.FALSE));
     }
-    
+
     @Test
     public void test_toString_Boolean_String_String_String() {
         assertEquals("U", BooleanUtils.toString(null, "Y", "N", "U"));
         assertEquals("Y", BooleanUtils.toString(Boolean.TRUE, "Y", "N", "U"));
         assertEquals("N", BooleanUtils.toString(Boolean.FALSE, "Y", "N", "U"));
     }
-    
+
     //-----------------------------------------------------------------------
     @Test
     public void test_toStringTrueFalse_boolean() {
         assertEquals("true", BooleanUtils.toStringTrueFalse(true));
         assertEquals("false", BooleanUtils.toStringTrueFalse(false));
     }
-    
+
     @Test
     public void test_toStringOnOff_boolean() {
         assertEquals("on", BooleanUtils.toStringOnOff(true));
         assertEquals("off", BooleanUtils.toStringOnOff(false));
     }
-    
+
     @Test
     public void test_toStringYesNo_boolean() {
         assertEquals("yes", BooleanUtils.toStringYesNo(true));
         assertEquals("no", BooleanUtils.toStringYesNo(false));
     }
-    
+
     @Test
     public void test_toString_boolean_String_String_String() {
         assertEquals("Y", BooleanUtils.toString(true, "Y", "N"));
         assertEquals("N", BooleanUtils.toString(false, "Y", "N"));
     }
-    
+
     //  testXor
     //  -----------------------------------------------------------------------
     @Test(expected = IllegalArgumentException.class)
@@ -519,7 +519,7 @@ public class BooleanUtilsTest {
     public void testXor_object_emptyInput() {
         BooleanUtils.xor(new Boolean[] {});
     }
-    
+
     @Test(expected = IllegalArgumentException.class)
     public void testXor_object_nullElementInput() {
         BooleanUtils.xor(new Boolean[] {null});
@@ -645,81 +645,81 @@ public class BooleanUtilsTest {
     public void testAnd_primitive_nullInput() {
         BooleanUtils.and((boolean[]) null);
     }
-    
+
     @Test(expected = IllegalArgumentException.class)
     public void testAnd_primitive_emptyInput() {
         BooleanUtils.and(new boolean[] {});
     }
-    
+
     @Test
     public void testAnd_primitive_validInput_2items() {
         assertTrue(
             "False result for (true, true)",
             BooleanUtils.and(new boolean[] { true, true }));
-        
+
         assertTrue(
             "True result for (false, false)",
             ! BooleanUtils.and(new boolean[] { false, false }));
-        
+
         assertTrue(
             "True result for (true, false)",
             ! BooleanUtils.and(new boolean[] { true, false }));
-        
+
         assertTrue(
             "True result for (false, true)",
             ! BooleanUtils.and(new boolean[] { false, true }));
     }
-    
+
     @Test
     public void testAnd_primitive_validInput_3items() {
         assertTrue(
             "True result for (false, false, true)",
             ! BooleanUtils.and(new boolean[] { false, false, true }));
-        
+
         assertTrue(
             "True result for (false, true, false)",
             ! BooleanUtils.and(new boolean[] { false, true, false }));
-        
+
         assertTrue(
             "True result for (true, false, false)",
             ! BooleanUtils.and(new boolean[] { true, false, false }));
-        
+
         assertTrue(
             "False result for (true, true, true)",
             BooleanUtils.and(new boolean[] { true, true, true }));
-        
+
         assertTrue(
             "True result for (false, false)",
             ! BooleanUtils.and(new boolean[] { false, false, false }));
-        
+
         assertTrue(
             "True result for (true, true, false)",
             ! BooleanUtils.and(new boolean[] { true, true, false }));
-        
+
         assertTrue(
             "True result for (true, false, true)",
             ! BooleanUtils.and(new boolean[] { true, false, true }));
-        
+
         assertTrue(
             "True result for (false, true, true)",
             ! BooleanUtils.and(new boolean[] { false, true, true }));
     }
-    
+
     @Test(expected = IllegalArgumentException.class)
     public void testAnd_object_nullInput() {
         BooleanUtils.and((Boolean[]) null);
     }
-    
+
     @Test(expected = IllegalArgumentException.class)
     public void testAnd_object_emptyInput() {
         BooleanUtils.and(new Boolean[] {});
     }
-    
+
     @Test(expected = IllegalArgumentException.class)
     public void testAnd_object_nullElementInput() {
         BooleanUtils.and(new Boolean[] {null});
     }
-    
+
     @Test
     public void testAnd_object_validInput_2items() {
         assertTrue(
@@ -727,26 +727,26 @@ public class BooleanUtilsTest {
             BooleanUtils
             .and(new Boolean[] { Boolean.TRUE, Boolean.TRUE })
             .booleanValue());
-        
+
         assertTrue(
             "True result for (false, false)",
             ! BooleanUtils
             .and(new Boolean[] { Boolean.FALSE, Boolean.FALSE })
             .booleanValue());
-        
+
         assertTrue(
             "True result for (true, false)",
             ! BooleanUtils
             .and(new Boolean[] { Boolean.TRUE, Boolean.FALSE })
             .booleanValue());
-        
+
         assertTrue(
             "True result for (false, true)",
             ! BooleanUtils
             .and(new Boolean[] { Boolean.FALSE, Boolean.TRUE })
             .booleanValue());
     }
-    
+
     @Test
     public void testAnd_object_validInput_3items() {
         assertTrue(
@@ -758,7 +758,7 @@ public class BooleanUtilsTest {
                     Boolean.FALSE,
                     Boolean.TRUE })
                     .booleanValue());
-        
+
         assertTrue(
             "True result for (false, true, false)",
             ! BooleanUtils
@@ -768,7 +768,7 @@ public class BooleanUtilsTest {
                     Boolean.TRUE,
                     Boolean.FALSE })
                     .booleanValue());
-        
+
         assertTrue(
             "True result for (true, false, false)",
             ! BooleanUtils
@@ -778,13 +778,13 @@ public class BooleanUtilsTest {
                     Boolean.FALSE,
                     Boolean.FALSE })
                     .booleanValue());
-        
+
         assertTrue(
             "False result for (true, true, true)",
             BooleanUtils
             .and(new Boolean[] { Boolean.TRUE, Boolean.TRUE, Boolean.TRUE })
             .booleanValue());
-        
+
         assertTrue(
             "True result for (false, false)",
             ! BooleanUtils.and(
@@ -793,7 +793,7 @@ public class BooleanUtilsTest {
                     Boolean.FALSE,
                     Boolean.FALSE })
                     .booleanValue());
-        
+
         assertTrue(
             "True result for (true, true, false)",
             ! BooleanUtils.and(
@@ -802,7 +802,7 @@ public class BooleanUtilsTest {
                     Boolean.TRUE,
                     Boolean.FALSE })
                     .booleanValue());
-        
+
         assertTrue(
             "True result for (true, false, true)",
             ! BooleanUtils.and(
@@ -811,7 +811,7 @@ public class BooleanUtilsTest {
                     Boolean.FALSE,
                     Boolean.TRUE })
                     .booleanValue());
-        
+
         assertTrue(
             "True result for (false, true, true)",
             ! BooleanUtils.and(
@@ -821,88 +821,88 @@ public class BooleanUtilsTest {
                     Boolean.TRUE })
                     .booleanValue());
     }
-    
+
     //  testOr
     //  -----------------------------------------------------------------------
     @Test(expected = IllegalArgumentException.class)
     public void testOr_primitive_nullInput() {
         BooleanUtils.or((boolean[]) null);
     }
-    
+
     @Test(expected = IllegalArgumentException.class)
     public void testOr_primitive_emptyInput() {
         BooleanUtils.or(new boolean[] {});
     }
-    
+
     @Test
     public void testOr_primitive_validInput_2items() {
         assertTrue(
             "False result for (true, true)",
             BooleanUtils.or(new boolean[] { true, true }));
-        
+
         assertTrue(
             "True result for (false, false)",
             ! BooleanUtils.or(new boolean[] { false, false }));
-        
+
         assertTrue(
             "False result for (true, false)",
             BooleanUtils.or(new boolean[] { true, false }));
-        
+
         assertTrue(
             "False result for (false, true)",
             BooleanUtils.or(new boolean[] { false, true }));
     }
-    
+
     @Test
     public void testOr_primitive_validInput_3items() {
         assertTrue(
             "False result for (false, false, true)",
             BooleanUtils.or(new boolean[] { false, false, true }));
-        
+
         assertTrue(
             "False result for (false, true, false)",
             BooleanUtils.or(new boolean[] { false, true, false }));
-        
+
         assertTrue(
             "False result for (true, false, false)",
             BooleanUtils.or(new boolean[] { true, false, false }));
-        
+
         assertTrue(
             "False result for (true, true, true)",
             BooleanUtils.or(new boolean[] { true, true, true }));
-        
+
         assertTrue(
             "True result for (false, false)",
             ! BooleanUtils.or(new boolean[] { false, false, false }));
-        
+
         assertTrue(
             "False result for (true, true, false)",
             BooleanUtils.or(new boolean[] { true, true, false }));
-        
+
         assertTrue(
             "False result for (true, false, true)",
             BooleanUtils.or(new boolean[] { true, false, true }));
-        
+
         assertTrue(
             "False result for (false, true, true)",
             BooleanUtils.or(new boolean[] { false, true, true }));
-    
+
     }
     @Test(expected = IllegalArgumentException.class)
     public void testOr_object_nullInput() {
         BooleanUtils.or((Boolean[]) null);
     }
-    
+
     @Test(expected = IllegalArgumentException.class)
     public void testOr_object_emptyInput() {
         BooleanUtils.or(new Boolean[] {});
     }
-    
+
     @Test(expected = IllegalArgumentException.class)
     public void testOr_object_nullElementInput() {
         BooleanUtils.or(new Boolean[] {null});
     }
-    
+
     @Test
     public void testOr_object_validInput_2items() {
         assertTrue(
@@ -910,26 +910,26 @@ public class BooleanUtilsTest {
             BooleanUtils
             .or(new Boolean[] { Boolean.TRUE, Boolean.TRUE })
             .booleanValue());
-        
+
         assertTrue(
             "True result for (false, false)",
             ! BooleanUtils
             .or(new Boolean[] { Boolean.FALSE, Boolean.FALSE })
             .booleanValue());
-        
+
         assertTrue(
             "False result for (true, false)",
             BooleanUtils
             .or(new Boolean[] { Boolean.TRUE, Boolean.FALSE })
             .booleanValue());
-        
+
         assertTrue(
             "False result for (false, true)",
             BooleanUtils
             .or(new Boolean[] { Boolean.FALSE, Boolean.TRUE })
             .booleanValue());
     }
-    
+
     @Test
     public void testOr_object_validInput_3items() {
         assertTrue(
@@ -941,7 +941,7 @@ public class BooleanUtilsTest {
                     Boolean.FALSE,
                     Boolean.TRUE })
                     .booleanValue());
-        
+
         assertTrue(
             "False result for (false, true, false)",
             BooleanUtils
@@ -951,7 +951,7 @@ public class BooleanUtilsTest {
                     Boolean.TRUE,
                     Boolean.FALSE })
                     .booleanValue());
-        
+
         assertTrue(
             "False result for (true, false, false)",
             BooleanUtils
@@ -961,13 +961,13 @@ public class BooleanUtilsTest {
                     Boolean.FALSE,
                     Boolean.FALSE })
                     .booleanValue());
-        
+
         assertTrue(
             "False result for (true, true, true)",
             BooleanUtils
             .or(new Boolean[] { Boolean.TRUE, Boolean.TRUE, Boolean.TRUE })
             .booleanValue());
-        
+
         assertTrue(
             "True result for (false, false)",
             ! BooleanUtils.or(
@@ -976,7 +976,7 @@ public class BooleanUtilsTest {
                     Boolean.FALSE,
                     Boolean.FALSE })
                     .booleanValue());
-        
+
         assertTrue(
             "False result for (true, true, false)",
             BooleanUtils.or(
@@ -985,7 +985,7 @@ public class BooleanUtilsTest {
                     Boolean.TRUE,
                     Boolean.FALSE })
                     .booleanValue());
-        
+
         assertTrue(
             "False result for (true, false, true)",
             BooleanUtils.or(
@@ -994,7 +994,7 @@ public class BooleanUtilsTest {
                     Boolean.FALSE,
                     Boolean.TRUE })
                     .booleanValue());
-        
+
         assertTrue(
             "False result for (false, true, true)",
             BooleanUtils.or(
@@ -1012,5 +1012,5 @@ public class BooleanUtilsTest {
         assertTrue(BooleanUtils.compare(false, false) == 0);
         assertTrue(BooleanUtils.compare(false, true) < 0);
     }
-    
+
 }

http://git-wip-us.apache.org/repos/asf/commons-lang/blob/1da8ccdb/src/test/java/org/apache/commons/lang3/CharEncodingTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/lang3/CharEncodingTest.java b/src/test/java/org/apache/commons/lang3/CharEncodingTest.java
index 9e8e540..7999457 100644
--- a/src/test/java/org/apache/commons/lang3/CharEncodingTest.java
+++ b/src/test/java/org/apache/commons/lang3/CharEncodingTest.java
@@ -5,9 +5,9 @@
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -24,7 +24,7 @@ import org.junit.Test;
 
 /**
  * Tests CharEncoding.
- * 
+ *
  * @see CharEncoding
  */
 @SuppressWarnings("deprecation")

http://git-wip-us.apache.org/repos/asf/commons-lang/blob/1da8ccdb/src/test/java/org/apache/commons/lang3/CharRangeTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/lang3/CharRangeTest.java b/src/test/java/org/apache/commons/lang3/CharRangeTest.java
index b36e43e..83a1008 100644
--- a/src/test/java/org/apache/commons/lang3/CharRangeTest.java
+++ b/src/test/java/org/apache/commons/lang3/CharRangeTest.java
@@ -390,11 +390,11 @@ public class CharRangeTest  {
     @Test
     public void testSerialization() {
         CharRange range = CharRange.is('a');
-        assertEquals(range, SerializationUtils.clone(range)); 
+        assertEquals(range, SerializationUtils.clone(range));
         range = CharRange.isIn('a', 'e');
-        assertEquals(range, SerializationUtils.clone(range)); 
+        assertEquals(range, SerializationUtils.clone(range));
         range = CharRange.isNotIn('a', 'e');
-        assertEquals(range, SerializationUtils.clone(range)); 
+        assertEquals(range, SerializationUtils.clone(range));
     }
 
     //-----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/commons-lang/blob/1da8ccdb/src/test/java/org/apache/commons/lang3/CharSequenceUtilsTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/lang3/CharSequenceUtilsTest.java b/src/test/java/org/apache/commons/lang3/CharSequenceUtilsTest.java
index 591bf38..8240619 100644
--- a/src/test/java/org/apache/commons/lang3/CharSequenceUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/CharSequenceUtilsTest.java
@@ -43,7 +43,7 @@ public class CharSequenceUtilsTest {
         assertTrue(Modifier.isPublic(CharSequenceUtils.class.getModifiers()));
         assertFalse(Modifier.isFinal(CharSequenceUtils.class.getModifiers()));
     }
-    
+
     //-----------------------------------------------------------------------
     @Test
     public void testSubSequence() {
@@ -138,9 +138,9 @@ public class CharSequenceUtilsTest {
     };
 
     private static abstract class RunTest {
-        
+
         abstract boolean invoke();
-        
+
         void run(final TestData data, final String id) {
             if (data.throwable != null) {
                 try {
@@ -156,7 +156,7 @@ public class CharSequenceUtilsTest {
                 assertEquals(id + " Failed test " + data, data.expected, stringCheck);
             }
         }
-        
+
     }
 
     @Test
@@ -165,25 +165,25 @@ public class CharSequenceUtilsTest {
             new RunTest() {
                 @Override
                 boolean invoke() {
-                    return data.source.regionMatches(data.ignoreCase, data.toffset, data.other, data.ooffset, data.len);                        
+                    return data.source.regionMatches(data.ignoreCase, data.toffset, data.other, data.ooffset, data.len);
                 }
             }.run(data, "String");
             new RunTest() {
                 @Override
                 boolean invoke() {
-                    return CharSequenceUtils.regionMatches(data.source, data.ignoreCase, data.toffset, data.other, data.ooffset, data.len);                        
+                    return CharSequenceUtils.regionMatches(data.source, data.ignoreCase, data.toffset, data.other, data.ooffset, data.len);
                 }
             }.run(data, "CSString");
             new RunTest() {
                 @Override
                 boolean invoke() {
-                    return CharSequenceUtils.regionMatches(new StringBuilder(data.source), data.ignoreCase, data.toffset, data.other, data.ooffset, data.len);             
+                    return CharSequenceUtils.regionMatches(new StringBuilder(data.source), data.ignoreCase, data.toffset, data.other, data.ooffset, data.len);
                 }
             }.run(data, "CSNonString");
         }
     }
-    
-    
+
+
     @Test
     public void testToCharArray() throws Exception {
         final StringBuilder builder = new StringBuilder("abcdefg");

http://git-wip-us.apache.org/repos/asf/commons-lang/blob/1da8ccdb/src/test/java/org/apache/commons/lang3/CharSetTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/lang3/CharSetTest.java b/src/test/java/org/apache/commons/lang3/CharSetTest.java
index 2c05e98..035dc4b 100644
--- a/src/test/java/org/apache/commons/lang3/CharSetTest.java
+++ b/src/test/java/org/apache/commons/lang3/CharSetTest.java
@@ -38,7 +38,7 @@ public class CharSetTest  {
         assertTrue(Modifier.isPublic(CharSet.class.getModifiers()));
         assertFalse(Modifier.isFinal(CharSet.class.getModifiers()));
     }
-    
+
     //-----------------------------------------------------------------------
     @Test
     public void testGetInstance() {
@@ -59,78 +59,78 @@ public class CharSetTest  {
         assertEquals("[]", CharSet.getInstance(new String[] {null}).toString());
         assertEquals("[a-e]", CharSet.getInstance(new String[] {"a-e"}).toString());
     }
-    
+
     //-----------------------------------------------------------------------
     @Test
     public void testConstructor_String_simple() {
         CharSet set;
         CharRange[] array;
-        
+
         set = CharSet.getInstance((String) null);
         array = set.getCharRanges();
         assertEquals("[]", set.toString());
         assertEquals(0, array.length);
-        
+
         set = CharSet.getInstance("");
         array = set.getCharRanges();
         assertEquals("[]", set.toString());
         assertEquals(0, array.length);
-        
+
         set = CharSet.getInstance("a");
         array = set.getCharRanges();
         assertEquals("[a]", set.toString());
         assertEquals(1, array.length);
         assertEquals("a", array[0].toString());
-        
+
         set = CharSet.getInstance("^a");
         array = set.getCharRanges();
         assertEquals("[^a]", set.toString());
         assertEquals(1, array.length);
         assertEquals("^a", array[0].toString());
-        
+
         set = CharSet.getInstance("a-e");
         array = set.getCharRanges();
         assertEquals("[a-e]", set.toString());
         assertEquals(1, array.length);
         assertEquals("a-e", array[0].toString());
-        
+
         set = CharSet.getInstance("^a-e");
         array = set.getCharRanges();
         assertEquals("[^a-e]", set.toString());
         assertEquals(1, array.length);
         assertEquals("^a-e", array[0].toString());
     }
-    
+
     @Test
     public void testConstructor_String_combo() {
         CharSet set;
         CharRange[] array;
-        
+
         set = CharSet.getInstance("abc");
         array = set.getCharRanges();
         assertEquals(3, array.length);
         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);
         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);
         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);
         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);
@@ -139,26 +139,26 @@ public class CharSetTest  {
         assertTrue(ArrayUtils.contains(array, CharRange.isIn('m', 'p')));
         assertTrue(ArrayUtils.contains(array, CharRange.is('z')));
     }
-    
+
     @Test
     public void testConstructor_String_comboNegated() {
         CharSet set;
         CharRange[] array;
-        
+
         set = CharSet.getInstance("^abc");
         array = set.getCharRanges();
         assertEquals(3, array.length);
         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);
         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);
@@ -166,13 +166,13 @@ public class CharSetTest  {
         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);
         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);
@@ -185,50 +185,50 @@ public class CharSetTest  {
     public void testConstructor_String_oddDash() {
         CharSet set;
         CharRange[] array;
-        
+
         set = CharSet.getInstance("-");
         array = set.getCharRanges();
         assertEquals(1, array.length);
         assertTrue(ArrayUtils.contains(array, CharRange.is('-')));
-        
+
         set = CharSet.getInstance("--");
         array = set.getCharRanges();
         assertEquals(1, array.length);
         assertTrue(ArrayUtils.contains(array, CharRange.is('-')));
-        
+
         set = CharSet.getInstance("---");
         array = set.getCharRanges();
         assertEquals(1, array.length);
         assertTrue(ArrayUtils.contains(array, CharRange.is('-')));
-        
+
         set = CharSet.getInstance("----");
         array = set.getCharRanges();
         assertEquals(1, array.length);
         assertTrue(ArrayUtils.contains(array, CharRange.is('-')));
-        
+
         set = CharSet.getInstance("-a");
         array = set.getCharRanges();
         assertEquals(2, array.length);
         assertTrue(ArrayUtils.contains(array, CharRange.is('-')));
         assertTrue(ArrayUtils.contains(array, CharRange.is('a')));
-        
+
         set = CharSet.getInstance("a-");
         array = set.getCharRanges();
         assertEquals(2, array.length);
         assertTrue(ArrayUtils.contains(array, CharRange.is('a')));
         assertTrue(ArrayUtils.contains(array, CharRange.is('-')));
-        
+
         set = CharSet.getInstance("a--");
         array = set.getCharRanges();
         assertEquals(1, array.length);
         assertTrue(ArrayUtils.contains(array, CharRange.isIn('a', '-')));
-        
+
         set = CharSet.getInstance("--a");
         array = set.getCharRanges();
         assertEquals(1, array.length);
         assertTrue(ArrayUtils.contains(array, CharRange.isIn('-', 'a')));
     }
-    
+
     @Test
     public void testConstructor_String_oddNegate() {
         CharSet set;
@@ -237,80 +237,80 @@ public class CharSetTest  {
         array = set.getCharRanges();
         assertEquals(1, array.length);
         assertTrue(ArrayUtils.contains(array, CharRange.is('^'))); // "^"
-        
+
         set = CharSet.getInstance("^^");
         array = set.getCharRanges();
         assertEquals(1, array.length);
         assertTrue(ArrayUtils.contains(array, CharRange.isNot('^'))); // "^^"
-        
+
         set = CharSet.getInstance("^^^");
         array = set.getCharRanges();
         assertEquals(2, array.length);
         assertTrue(ArrayUtils.contains(array, CharRange.isNot('^'))); // "^^"
         assertTrue(ArrayUtils.contains(array, CharRange.is('^'))); // "^"
-        
+
         set = CharSet.getInstance("^^^^");
         array = set.getCharRanges();
         assertEquals(1, array.length);
         assertTrue(ArrayUtils.contains(array, CharRange.isNot('^'))); // "^^" x2
-        
+
         set = CharSet.getInstance("a^");
         array = set.getCharRanges();
         assertEquals(2, array.length);
         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);
         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);
         assertTrue(ArrayUtils.contains(array, CharRange.isNotIn('^', 'c'))); // "^^-c"
-        
+
         set = CharSet.getInstance("^c-^");
         array = set.getCharRanges();
         assertEquals(1, array.length);
         assertTrue(ArrayUtils.contains(array, CharRange.isNotIn('c', '^'))); // "^c-^"
-        
+
         set = CharSet.getInstance("^c-^d");
         array = set.getCharRanges();
         assertEquals(2, array.length);
         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);
         assertTrue(ArrayUtils.contains(array, CharRange.isNot('^'))); // "^^"
         assertTrue(ArrayUtils.contains(array, CharRange.is('-'))); // "-"
     }
-    
+
     @Test
     public void testConstructor_String_oddCombinations() {
         CharSet set;
         CharRange[] array = null;
-        
+
         set = CharSet.getInstance("a-^c");
         array = set.getCharRanges();
         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('^'));
         assertTrue(set.contains('_')); // between ^ and a
-        assertTrue(set.contains('c'));  
-        
+        assertTrue(set.contains('c'));
+
         set = CharSet.getInstance("^a-^c");
         array = set.getCharRanges();
         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('^'));
         assertFalse(set.contains('_')); // between ^ and a
-        
+
         set = CharSet.getInstance("a- ^-- "); //contains everything
         array = set.getCharRanges();
         assertTrue(ArrayUtils.contains(array, CharRange.isIn('a', ' '))); // "a- "
@@ -320,25 +320,25 @@ public class CharSetTest  {
         assertTrue(set.contains('a'));
         assertTrue(set.contains('*'));
         assertTrue(set.contains('A'));
-        
+
         set = CharSet.getInstance("^-b");
         array = set.getCharRanges();
         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('^')); 
-        
+        assertTrue(set.contains('^'));
+
         set = CharSet.getInstance("b-^");
         array = set.getCharRanges();
         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')); 
+        assertFalse(set.contains('c'));
     }
-        
-    //-----------------------------------------------------------------------    
+
+    //-----------------------------------------------------------------------
     @Test
     public void testEquals_Object() {
         final CharSet abc = CharSet.getInstance("abc");
@@ -347,25 +347,25 @@ public class CharSetTest  {
         final CharSet atoc2 = CharSet.getInstance("a-c");
         final CharSet notatoc = CharSet.getInstance("^a-c");
         final CharSet notatoc2 = CharSet.getInstance("^a-c");
-        
+
         assertFalse(abc.equals(null));
-        
+
         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
     public void testHashCode() {
         final CharSet abc = CharSet.getInstance("abc");
@@ -374,7 +374,7 @@ public class CharSetTest  {
         final CharSet atoc2 = CharSet.getInstance("a-c");
         final CharSet notatoc = CharSet.getInstance("^a-c");
         final CharSet notatoc2 = CharSet.getInstance("^a-c");
-        
+
         assertEquals(abc.hashCode(), abc.hashCode());
         assertEquals(abc.hashCode(), abc2.hashCode());
         assertEquals(atoc.hashCode(), atoc.hashCode());
@@ -382,8 +382,8 @@ public class CharSetTest  {
         assertEquals(notatoc.hashCode(), notatoc.hashCode());
         assertEquals(notatoc.hashCode(), notatoc2.hashCode());
     }
-    
-    //-----------------------------------------------------------------------    
+
+    //-----------------------------------------------------------------------
     @Test
     public void testContains_Char() {
         final CharSet btod = CharSet.getInstance("b-d");
@@ -391,79 +391,79 @@ public class CharSetTest  {
         final CharSet bcd = CharSet.getInstance("bcd");
         final CharSet bd = CharSet.getInstance("bd");
         final CharSet notbtod = CharSet.getInstance("^b-d");
-        
+
         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'));
-      
+
         final CharRange[] array = dtob.getCharRanges();
         assertEquals("[b-d]", dtob.toString());
         assertEquals(1, array.length);
     }
-    
-    //-----------------------------------------------------------------------    
+
+    //-----------------------------------------------------------------------
     @Test
     public void testSerialization() {
         CharSet set = CharSet.getInstance("a");
-        assertEquals(set, SerializationUtils.clone(set)); 
+        assertEquals(set, SerializationUtils.clone(set));
         set = CharSet.getInstance("a-e");
-        assertEquals(set, SerializationUtils.clone(set)); 
+        assertEquals(set, SerializationUtils.clone(set));
         set = CharSet.getInstance("be-f^a-z");
-        assertEquals(set, SerializationUtils.clone(set)); 
+        assertEquals(set, SerializationUtils.clone(set));
     }
-    
-    //-----------------------------------------------------------------------    
+
+    //-----------------------------------------------------------------------
     @Test
     public void testStatics() {
         CharRange[] array;
-        
+
         array = CharSet.EMPTY.getCharRanges();
         assertEquals(0, array.length);
-        
+
         array = CharSet.ASCII_ALPHA.getCharRanges();
         assertEquals(2, array.length);
         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);
         assertTrue(ArrayUtils.contains(array, CharRange.isIn('a', 'z')));
-        
+
         array = CharSet.ASCII_ALPHA_UPPER.getCharRanges();
         assertEquals(1, array.length);
         assertTrue(ArrayUtils.contains(array, CharRange.isIn('A', 'Z')));
-        
+
         array = CharSet.ASCII_NUMERIC.getCharRanges();
         assertEquals(1, array.length);
         assertTrue(ArrayUtils.contains(array, CharRange.isIn('0', '9')));
     }
-    
+
     @Test
     public void testJavadocExamples() throws Exception {
         assertFalse(CharSet.getInstance("^a-c").contains('a'));
@@ -472,6 +472,6 @@ public class CharSetTest  {
         assertFalse(CharSet.getInstance("^^a-c").contains('^'));
         assertTrue(CharSet.getInstance("^a-cd-f").contains('d'));
         assertTrue(CharSet.getInstance("a-c^").contains('^'));
-        assertTrue(CharSet.getInstance("^", "a-c").contains('^'));        
+        assertTrue(CharSet.getInstance("^", "a-c").contains('^'));
     }
 }

http://git-wip-us.apache.org/repos/asf/commons-lang/blob/1da8ccdb/src/test/java/org/apache/commons/lang3/CharSetUtilsTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/lang3/CharSetUtilsTest.java b/src/test/java/org/apache/commons/lang3/CharSetUtilsTest.java
index 9b74d35..829ff6c 100644
--- a/src/test/java/org/apache/commons/lang3/CharSetUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/CharSetUtilsTest.java
@@ -5,9 +5,9 @@
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -41,17 +41,17 @@ public class CharSetUtilsTest  {
         assertTrue(Modifier.isPublic(CharSetUtils.class.getModifiers()));
         assertFalse(Modifier.isFinal(CharSetUtils.class.getModifiers()));
     }
-    
+
     //-----------------------------------------------------------------------
     @Test
     public void testSqueeze_StringString() {
         assertEquals(null, CharSetUtils.squeeze(null, (String) null));
         assertEquals(null, CharSetUtils.squeeze(null, ""));
-        
+
         assertEquals("", CharSetUtils.squeeze("", (String) null));
         assertEquals("", CharSetUtils.squeeze("", ""));
         assertEquals("", CharSetUtils.squeeze("", "a-e"));
-        
+
         assertEquals("hello", CharSetUtils.squeeze("hello", (String) null));
         assertEquals("hello", CharSetUtils.squeeze("hello", ""));
         assertEquals("hello", CharSetUtils.squeeze("hello", "a-e"));
@@ -59,24 +59,24 @@ public class CharSetUtilsTest  {
         assertEquals("heloo", CharSetUtils.squeeze("helloo", "l"));
         assertEquals("hello", CharSetUtils.squeeze("helloo", "^l"));
     }
-    
+
     @Test
     public void testSqueeze_StringStringarray() {
         assertEquals(null, CharSetUtils.squeeze(null, (String[]) null));
         assertEquals(null, CharSetUtils.squeeze(null, new String[0]));
         assertEquals(null, CharSetUtils.squeeze(null, new String[] {null}));
         assertEquals(null, CharSetUtils.squeeze(null, new String[] {"el"}));
-        
+
         assertEquals("", CharSetUtils.squeeze("", (String[]) null));
         assertEquals("", CharSetUtils.squeeze("", new String[0]));
         assertEquals("", CharSetUtils.squeeze("", new String[] {null}));
         assertEquals("", CharSetUtils.squeeze("", new String[] {"a-e"}));
-        
+
         assertEquals("hello", CharSetUtils.squeeze("hello", (String[]) null));
         assertEquals("hello", CharSetUtils.squeeze("hello", new String[0]));
         assertEquals("hello", CharSetUtils.squeeze("hello", new String[] {null}));
         assertEquals("hello", CharSetUtils.squeeze("hello", new String[] {"a-e"}));
-        
+
         assertEquals("helo", CharSetUtils.squeeze("hello", new String[] { "el" }));
         assertEquals("hello", CharSetUtils.squeeze("hello", new String[] { "e" }));
         assertEquals("fofof", CharSetUtils.squeeze("fooffooff", new String[] { "of" }));
@@ -88,34 +88,34 @@ public class CharSetUtilsTest  {
     public void testContainsAny_StringString() {
         assertFalse(CharSetUtils.containsAny(null, (String) null));
         assertFalse(CharSetUtils.containsAny(null, ""));
-        
+
         assertFalse(CharSetUtils.containsAny("", (String) null));
         assertFalse(CharSetUtils.containsAny("", ""));
         assertFalse(CharSetUtils.containsAny("", "a-e"));
-        
+
         assertFalse(CharSetUtils.containsAny("hello", (String) null));
         assertFalse(CharSetUtils.containsAny("hello", ""));
         assertTrue(CharSetUtils.containsAny("hello", "a-e"));
         assertTrue(CharSetUtils.containsAny("hello", "l-p"));
     }
-    
+
     @Test
     public void testContainsAny_StringStringarray() {
         assertFalse(CharSetUtils.containsAny(null, (String[]) null));
         assertFalse(CharSetUtils.containsAny(null, new String[0]));
         assertFalse(CharSetUtils.containsAny(null, new String[] {null}));
         assertFalse(CharSetUtils.containsAny(null, new String[] {"a-e"}));
-        
+
         assertFalse(CharSetUtils.containsAny("", (String[]) null));
         assertFalse(CharSetUtils.containsAny("", new String[0]));
         assertFalse(CharSetUtils.containsAny("", new String[] {null}));
         assertFalse(CharSetUtils.containsAny("", new String[] {"a-e"}));
-        
+
         assertFalse(CharSetUtils.containsAny("hello", (String[]) null));
         assertFalse(CharSetUtils.containsAny("hello", new String[0]));
         assertFalse(CharSetUtils.containsAny("hello", new String[] {null}));
         assertTrue(CharSetUtils.containsAny("hello", new String[] {"a-e"}));
-        
+
         assertTrue(CharSetUtils.containsAny("hello", new String[] { "el" }));
         assertFalse(CharSetUtils.containsAny("hello", new String[] { "x" }));
         assertTrue(CharSetUtils.containsAny("hello", new String[] { "e-i" }));
@@ -128,34 +128,34 @@ public class CharSetUtilsTest  {
     public void testCount_StringString() {
         assertEquals(0, CharSetUtils.count(null, (String) null));
         assertEquals(0, CharSetUtils.count(null, ""));
-        
+
         assertEquals(0, CharSetUtils.count("", (String) null));
         assertEquals(0, CharSetUtils.count("", ""));
         assertEquals(0, CharSetUtils.count("", "a-e"));
-        
+
         assertEquals(0, CharSetUtils.count("hello", (String) null));
         assertEquals(0, CharSetUtils.count("hello", ""));
         assertEquals(1, CharSetUtils.count("hello", "a-e"));
         assertEquals(3, CharSetUtils.count("hello", "l-p"));
     }
-    
+
     @Test
     public void testCount_StringStringarray() {
         assertEquals(0, CharSetUtils.count(null, (String[]) null));
         assertEquals(0, CharSetUtils.count(null, new String[0]));
         assertEquals(0, CharSetUtils.count(null, new String[] {null}));
         assertEquals(0, CharSetUtils.count(null, new String[] {"a-e"}));
-        
+
         assertEquals(0, CharSetUtils.count("", (String[]) null));
         assertEquals(0, CharSetUtils.count("", new String[0]));
         assertEquals(0, CharSetUtils.count("", new String[] {null}));
         assertEquals(0, CharSetUtils.count("", new String[] {"a-e"}));
-        
+
         assertEquals(0, CharSetUtils.count("hello", (String[]) null));
         assertEquals(0, CharSetUtils.count("hello", new String[0]));
         assertEquals(0, CharSetUtils.count("hello", new String[] {null}));
         assertEquals(1, CharSetUtils.count("hello", new String[] {"a-e"}));
-        
+
         assertEquals(3, CharSetUtils.count("hello", new String[] { "el" }));
         assertEquals(0, CharSetUtils.count("hello", new String[] { "x" }));
         assertEquals(2, CharSetUtils.count("hello", new String[] { "e-i" }));
@@ -168,11 +168,11 @@ public class CharSetUtilsTest  {
     public void testKeep_StringString() {
         assertEquals(null, CharSetUtils.keep(null, (String) null));
         assertEquals(null, CharSetUtils.keep(null, ""));
-        
+
         assertEquals("", CharSetUtils.keep("", (String) null));
         assertEquals("", CharSetUtils.keep("", ""));
         assertEquals("", CharSetUtils.keep("", "a-e"));
-        
+
         assertEquals("", CharSetUtils.keep("hello", (String) null));
         assertEquals("", CharSetUtils.keep("hello", ""));
         assertEquals("", CharSetUtils.keep("hello", "xyz"));
@@ -180,24 +180,24 @@ public class CharSetUtilsTest  {
         assertEquals("hello", CharSetUtils.keep("hello", "oleh"));
         assertEquals("ell", CharSetUtils.keep("hello", "el"));
     }
-    
+
     @Test
     public void testKeep_StringStringarray() {
         assertEquals(null, CharSetUtils.keep(null, (String[]) null));
         assertEquals(null, CharSetUtils.keep(null, new String[0]));
         assertEquals(null, CharSetUtils.keep(null, new String[] {null}));
         assertEquals(null, CharSetUtils.keep(null, new String[] {"a-e"}));
-        
+
         assertEquals("", CharSetUtils.keep("", (String[]) null));
         assertEquals("", CharSetUtils.keep("", new String[0]));
         assertEquals("", CharSetUtils.keep("", new String[] {null}));
         assertEquals("", CharSetUtils.keep("", new String[] {"a-e"}));
-        
+
         assertEquals("", CharSetUtils.keep("hello", (String[]) null));
         assertEquals("", CharSetUtils.keep("hello", new String[0]));
         assertEquals("", CharSetUtils.keep("hello", new String[] {null}));
         assertEquals("e", CharSetUtils.keep("hello", new String[] {"a-e"}));
-        
+
         assertEquals("e", CharSetUtils.keep("hello", new String[] { "a-e" }));
         assertEquals("ell", CharSetUtils.keep("hello", new String[] { "el" }));
         assertEquals("hello", CharSetUtils.keep("hello", new String[] { "elho" }));
@@ -211,30 +211,30 @@ public class CharSetUtilsTest  {
     public void testDelete_StringString() {
         assertEquals(null, CharSetUtils.delete(null, (String) null));
         assertEquals(null, CharSetUtils.delete(null, ""));
-        
+
         assertEquals("", CharSetUtils.delete("", (String) null));
         assertEquals("", CharSetUtils.delete("", ""));
         assertEquals("", CharSetUtils.delete("", "a-e"));
-        
+
         assertEquals("hello", CharSetUtils.delete("hello", (String) null));
         assertEquals("hello", CharSetUtils.delete("hello", ""));
         assertEquals("hllo", CharSetUtils.delete("hello", "a-e"));
         assertEquals("he", CharSetUtils.delete("hello", "l-p"));
         assertEquals("hello", CharSetUtils.delete("hello", "z"));
     }
-    
+
     @Test
     public void testDelete_StringStringarray() {
         assertEquals(null, CharSetUtils.delete(null, (String[]) null));
         assertEquals(null, CharSetUtils.delete(null, new String[0]));
         assertEquals(null, CharSetUtils.delete(null, new String[] {null}));
         assertEquals(null, CharSetUtils.delete(null, new String[] {"el"}));
-        
+
         assertEquals("", CharSetUtils.delete("", (String[]) null));
         assertEquals("", CharSetUtils.delete("", new String[0]));
         assertEquals("", CharSetUtils.delete("", new String[] {null}));
         assertEquals("", CharSetUtils.delete("", new String[] {"a-e"}));
-        
+
         assertEquals("hello", CharSetUtils.delete("hello", (String[]) null));
         assertEquals("hello", CharSetUtils.delete("hello", new String[0]));
         assertEquals("hello", CharSetUtils.delete("hello", new String[] {null}));
@@ -248,5 +248,5 @@ public class CharSetUtilsTest  {
         assertEquals("", CharSetUtils.delete("----", new String[] { "-" }));
         assertEquals("heo", CharSetUtils.delete("hello", new String[] { "l" }));
     }
-    
+
 }

http://git-wip-us.apache.org/repos/asf/commons-lang/blob/1da8ccdb/src/test/java/org/apache/commons/lang3/CharUtilsPerfRun.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/lang3/CharUtilsPerfRun.java b/src/test/java/org/apache/commons/lang3/CharUtilsPerfRun.java
index 5cc4e2f..7ab88b2 100644
--- a/src/test/java/org/apache/commons/lang3/CharUtilsPerfRun.java
+++ b/src/test/java/org/apache/commons/lang3/CharUtilsPerfRun.java
@@ -5,9 +5,9 @@
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -22,7 +22,7 @@ import java.util.Calendar;
 
 /**
  * Tests the difference in performance between CharUtils and CharSet.
- * 
+ *
  * Sample runs:
 
 Now: Thu Mar 18 14:29:48 PST 2004

http://git-wip-us.apache.org/repos/asf/commons-lang/blob/1da8ccdb/src/test/java/org/apache/commons/lang3/CharUtilsTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/lang3/CharUtilsTest.java b/src/test/java/org/apache/commons/lang3/CharUtilsTest.java
index ea68ada..bd92c33 100644
--- a/src/test/java/org/apache/commons/lang3/CharUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/CharUtilsTest.java
@@ -5,9 +5,9 @@
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -35,7 +35,7 @@ public class CharUtilsTest {
     private static final Character CHARACTER_A = new Character('A');
     private static final Character CHARACTER_B = new Character('B');
     private static final char CHAR_COPY = '\u00a9';
-    
+
     @Test
     public void testConstructor() {
         assertNotNull(new CharUtils());
@@ -45,13 +45,13 @@ public class CharUtilsTest {
         assertTrue(Modifier.isPublic(BooleanUtils.class.getModifiers()));
         assertFalse(Modifier.isFinal(BooleanUtils.class.getModifiers()));
     }
-    
+
     @SuppressWarnings("deprecation") // intentional test of deprecated method
     @Test
     public void testToCharacterObject_char() {
         assertEquals(new Character('a'), CharUtils.toCharacterObject('a'));
         assertSame(CharUtils.toCharacterObject('a'), CharUtils.toCharacterObject('a'));
-       
+
         for (int i = 0; i < 128; i++) {
             final Character ch = CharUtils.toCharacterObject((char) i);
             final Character ch2 = CharUtils.toCharacterObject((char) i);
@@ -68,7 +68,7 @@ public class CharUtilsTest {
         }
         assertSame(CharUtils.toCharacterObject("a"), CharUtils.toCharacterObject('a'));
     }
-    
+
     @Test
     public void testToCharacterObject_String() {
         assertEquals(null, CharUtils.toCharacterObject(null));
@@ -77,7 +77,7 @@ public class CharUtilsTest {
         assertEquals(new Character('a'), CharUtils.toCharacterObject("abc"));
         assertSame(CharUtils.toCharacterObject("a"), CharUtils.toCharacterObject("a"));
     }
-    
+
     @Test
     public void testToChar_Character() {
         assertEquals('A', CharUtils.toChar(CHARACTER_A));
@@ -86,14 +86,14 @@ public class CharUtilsTest {
             CharUtils.toChar((Character) null);
         } catch (final IllegalArgumentException ex) {}
     }
-    
+
     @Test
     public void testToChar_Character_char() {
         assertEquals('A', CharUtils.toChar(CHARACTER_A, 'X'));
         assertEquals('B', CharUtils.toChar(CHARACTER_B, 'X'));
         assertEquals('X', CharUtils.toChar((Character) null, 'X'));
     }
-    
+
     @Test
     public void testToChar_String() {
         assertEquals('A', CharUtils.toChar("A"));
@@ -105,7 +105,7 @@ public class CharUtilsTest {
             CharUtils.toChar("");
         } catch (final IllegalArgumentException ex) {}
     }
-    
+
     @Test
     public void testToChar_String_char() {
         assertEquals('A', CharUtils.toChar("A", 'X'));
@@ -113,7 +113,7 @@ public class CharUtilsTest {
         assertEquals('X', CharUtils.toChar("", 'X'));
         assertEquals('X', CharUtils.toChar((String) null, 'X'));
     }
-    
+
     @Test
     public void testToIntValue_char() {
         assertEquals(0, CharUtils.toIntValue('0'));
@@ -130,14 +130,14 @@ public class CharUtilsTest {
             CharUtils.toIntValue('a');
         } catch (final IllegalArgumentException ex) {}
     }
-    
+
     @Test
     public void testToIntValue_char_int() {
         assertEquals(0, CharUtils.toIntValue('0', -1));
         assertEquals(3, CharUtils.toIntValue('3', -1));
         assertEquals(-1, CharUtils.toIntValue('a', -1));
     }
-    
+
     @Test
     public void testToIntValue_Character() {
         assertEquals(0, CharUtils.toIntValue(new Character('0')));
@@ -149,7 +149,7 @@ public class CharUtilsTest {
             CharUtils.toIntValue(CHARACTER_A);
         } catch (final IllegalArgumentException ex) {}
     }
-    
+
     @Test
     public void testToIntValue_Character_int() {
         assertEquals(0, CharUtils.toIntValue(new Character('0'), -1));
@@ -157,12 +157,12 @@ public class CharUtilsTest {
         assertEquals(-1, CharUtils.toIntValue(new Character('A'), -1));
         assertEquals(-1, CharUtils.toIntValue(null, -1));
     }
-    
+
     @Test
     public void testToString_char() {
         assertEquals("a", CharUtils.toString('a'));
         assertSame(CharUtils.toString('a'), CharUtils.toString('a'));
-       
+
         for (int i = 0; i < 128; i++) {
             final String str = CharUtils.toString((char) i);
             final String str2 = CharUtils.toString((char) i);
@@ -181,19 +181,19 @@ public class CharUtilsTest {
             assertEquals(i, str2.charAt(0));
         }
     }
-    
+
     @Test
     public void testToString_Character() {
         assertEquals(null, CharUtils.toString(null));
         assertEquals("A", CharUtils.toString(CHARACTER_A));
         assertSame(CharUtils.toString(CHARACTER_A), CharUtils.toString(CHARACTER_A));
     }
-    
+
     @Test
     public void testToUnicodeEscaped_char() {
         assertEquals("\\u0041", CharUtils.unicodeEscaped('A'));
         assertEquals("\\u004c", CharUtils.unicodeEscaped('L'));
-       
+
         for (int i = 0; i < 196; i++) {
             final String str = CharUtils.unicodeEscaped((char) i);
             assertEquals(6, str.length());
@@ -203,13 +203,13 @@ public class CharUtilsTest {
         assertEquals("\\u0999", CharUtils.unicodeEscaped((char) 0x999));
         assertEquals("\\u1001", CharUtils.unicodeEscaped((char) 0x1001));
     }
-    
+
     @Test
     public void testToUnicodeEscaped_Character() {
         assertEquals(null, CharUtils.unicodeEscaped(null));
         assertEquals("\\u0041", CharUtils.unicodeEscaped(CHARACTER_A));
     }
-    
+
     @Test
     public void testIsAscii_char() {
         assertTrue(CharUtils.isAscii('a'));
@@ -218,7 +218,7 @@ public class CharUtilsTest {
         assertTrue(CharUtils.isAscii('-'));
         assertTrue(CharUtils.isAscii('\n'));
         assertFalse(CharUtils.isAscii(CHAR_COPY));
-       
+
         for (int i = 0; i < 128; i++) {
             if (i < 128) {
                 assertTrue(CharUtils.isAscii((char) i));
@@ -227,7 +227,7 @@ public class CharUtilsTest {
             }
         }
     }
-    
+
     @Test
     public void testIsAsciiPrintable_char() {
         assertTrue(CharUtils.isAsciiPrintable('a'));
@@ -236,7 +236,7 @@ public class CharUtilsTest {
         assertTrue(CharUtils.isAsciiPrintable('-'));
         assertFalse(CharUtils.isAsciiPrintable('\n'));
         assertFalse(CharUtils.isAsciiPrintable(CHAR_COPY));
-       
+
         for (int i = 0; i < 196; i++) {
             if (i >= 32 && i <= 126) {
                 assertTrue(CharUtils.isAsciiPrintable((char) i));
@@ -245,7 +245,7 @@ public class CharUtilsTest {
             }
         }
     }
-    
+
     @Test
     public void testIsAsciiControl_char() {
         assertFalse(CharUtils.isAsciiControl('a'));
@@ -254,7 +254,7 @@ public class CharUtilsTest {
         assertFalse(CharUtils.isAsciiControl('-'));
         assertTrue(CharUtils.isAsciiControl('\n'));
         assertFalse(CharUtils.isAsciiControl(CHAR_COPY));
-       
+
         for (int i = 0; i < 196; i++) {
             if (i < 32 || i == 127) {
                 assertTrue(CharUtils.isAsciiControl((char) i));
@@ -263,7 +263,7 @@ public class CharUtilsTest {
             }
         }
     }
-    
+
     @Test
     public void testIsAsciiAlpha_char() {
         assertTrue(CharUtils.isAsciiAlpha('a'));
@@ -272,7 +272,7 @@ public class CharUtilsTest {
         assertFalse(CharUtils.isAsciiAlpha('-'));
         assertFalse(CharUtils.isAsciiAlpha('\n'));
         assertFalse(CharUtils.isAsciiAlpha(CHAR_COPY));
-       
+
         for (int i = 0; i < 196; i++) {
             if ((i >= 'A' && i <= 'Z') || (i >= 'a' && i <= 'z')) {
                 assertTrue(CharUtils.isAsciiAlpha((char) i));
@@ -281,7 +281,7 @@ public class CharUtilsTest {
             }
         }
     }
-    
+
     @Test
     public void testIsAsciiAlphaUpper_char() {
         assertFalse(CharUtils.isAsciiAlphaUpper('a'));
@@ -290,7 +290,7 @@ public class CharUtilsTest {
         assertFalse(CharUtils.isAsciiAlphaUpper('-'));
         assertFalse(CharUtils.isAsciiAlphaUpper('\n'));
         assertFalse(CharUtils.isAsciiAlphaUpper(CHAR_COPY));
-       
+
         for (int i = 0; i < 196; i++) {
             if (i >= 'A' && i <= 'Z') {
                 assertTrue(CharUtils.isAsciiAlphaUpper((char) i));
@@ -299,7 +299,7 @@ public class CharUtilsTest {
             }
         }
     }
-    
+
     @Test
     public void testIsAsciiAlphaLower_char() {
         assertTrue(CharUtils.isAsciiAlphaLower('a'));
@@ -308,7 +308,7 @@ public class CharUtilsTest {
         assertFalse(CharUtils.isAsciiAlphaLower('-'));
         assertFalse(CharUtils.isAsciiAlphaLower('\n'));
         assertFalse(CharUtils.isAsciiAlphaLower(CHAR_COPY));
-       
+
         for (int i = 0; i < 196; i++) {
             if (i >= 'a' && i <= 'z') {
                 assertTrue(CharUtils.isAsciiAlphaLower((char) i));
@@ -317,7 +317,7 @@ public class CharUtilsTest {
             }
         }
     }
-    
+
     @Test
     public void testIsAsciiNumeric_char() {
         assertFalse(CharUtils.isAsciiNumeric('a'));
@@ -326,7 +326,7 @@ public class CharUtilsTest {
         assertFalse(CharUtils.isAsciiNumeric('-'));
         assertFalse(CharUtils.isAsciiNumeric('\n'));
         assertFalse(CharUtils.isAsciiNumeric(CHAR_COPY));
-       
+
         for (int i = 0; i < 196; i++) {
             if (i >= '0' && i <= '9') {
                 assertTrue(CharUtils.isAsciiNumeric((char) i));
@@ -335,7 +335,7 @@ public class CharUtilsTest {
             }
         }
     }
-    
+
     @Test
     public void testIsAsciiAlphanumeric_char() {
         assertTrue(CharUtils.isAsciiAlphanumeric('a'));
@@ -344,7 +344,7 @@ public class CharUtilsTest {
         assertFalse(CharUtils.isAsciiAlphanumeric('-'));
         assertFalse(CharUtils.isAsciiAlphanumeric('\n'));
         assertFalse(CharUtils.isAsciiAlphanumeric(CHAR_COPY));
-       
+
         for (int i = 0; i < 196; i++) {
             if ((i >= 'A' && i <= 'Z') || (i >= 'a' && i <= 'z') || (i >= '0' && i <= '9')) {
                 assertTrue(CharUtils.isAsciiAlphanumeric((char) i));

http://git-wip-us.apache.org/repos/asf/commons-lang/blob/1da8ccdb/src/test/java/org/apache/commons/lang3/ClassUtilsTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/lang3/ClassUtilsTest.java b/src/test/java/org/apache/commons/lang3/ClassUtilsTest.java
index 744aaa8..a31c78c 100644
--- a/src/test/java/org/apache/commons/lang3/ClassUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/ClassUtilsTest.java
@@ -114,7 +114,7 @@ public class ClassUtilsTest  {
         assertEquals("String[][]", ClassUtils.getShortClassName(String[][].class));
         assertEquals("String[][][]", ClassUtils.getShortClassName(String[][][].class));
         assertEquals("String[][][][]", ClassUtils.getShortClassName(String[][][][].class));
-        
+
         // Inner types
         class Named {}
         assertEquals("ClassUtilsTest.2", ClassUtils.getShortClassName(new Object(){}.getClass()));
@@ -166,7 +166,7 @@ public class ClassUtilsTest  {
         assertEquals("String[][]", ClassUtils.getSimpleName(String[][].class));
         assertEquals("String[][][]", ClassUtils.getSimpleName(String[][][].class));
         assertEquals("String[][][][]", ClassUtils.getSimpleName(String[][][][].class));
-        
+
         // On-the-fly types
         class Named {}
         assertEquals("", ClassUtils.getSimpleName(new Object(){}.getClass()));
@@ -212,7 +212,7 @@ public class ClassUtilsTest  {
         assertEquals("java.lang", ClassUtils.getPackageName(String[][].class));
         assertEquals("java.lang", ClassUtils.getPackageName(String[][][].class));
         assertEquals("java.lang", ClassUtils.getPackageName(String[][][][].class));
-        
+
         // On-the-fly types
         class Named {}
         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(new Object() {
@@ -783,7 +783,7 @@ public class ClassUtilsTest  {
         assertTrue("Long.class", ClassUtils.isPrimitiveOrWrapper(Long.class));
         assertTrue("Double.class", ClassUtils.isPrimitiveOrWrapper(Double.class));
         assertTrue("Float.class", ClassUtils.isPrimitiveOrWrapper(Float.class));
-        
+
         // test primitive classes
         assertTrue("boolean", ClassUtils.isPrimitiveOrWrapper(Boolean.TYPE));
         assertTrue("byte", ClassUtils.isPrimitiveOrWrapper(Byte.TYPE));
@@ -794,14 +794,14 @@ public class ClassUtilsTest  {
         assertTrue("double", ClassUtils.isPrimitiveOrWrapper(Double.TYPE));
         assertTrue("float", ClassUtils.isPrimitiveOrWrapper(Float.TYPE));
         assertTrue("Void.TYPE", ClassUtils.isPrimitiveOrWrapper(Void.TYPE));
-        
+
         // others
         assertFalse("null", ClassUtils.isPrimitiveOrWrapper(null));
         assertFalse("Void.class", ClassUtils.isPrimitiveOrWrapper(Void.class));
         assertFalse("String.class", ClassUtils.isPrimitiveOrWrapper(String.class));
         assertFalse("this.getClass()", ClassUtils.isPrimitiveOrWrapper(this.getClass()));
     }
-    
+
     @Test
     public void testIsPrimitiveWrapper() {
 
@@ -814,7 +814,7 @@ public class ClassUtilsTest  {
         assertTrue("Long.class", ClassUtils.isPrimitiveWrapper(Long.class));
         assertTrue("Double.class", ClassUtils.isPrimitiveWrapper(Double.class));
         assertTrue("Float.class", ClassUtils.isPrimitiveWrapper(Float.class));
-        
+
         // test primitive classes
         assertFalse("boolean", ClassUtils.isPrimitiveWrapper(Boolean.TYPE));
         assertFalse("byte", ClassUtils.isPrimitiveWrapper(Byte.TYPE));
@@ -824,7 +824,7 @@ public class ClassUtilsTest  {
         assertFalse("long", ClassUtils.isPrimitiveWrapper(Long.TYPE));
         assertFalse("double", ClassUtils.isPrimitiveWrapper(Double.TYPE));
         assertFalse("float", ClassUtils.isPrimitiveWrapper(Float.TYPE));
-        
+
         // others
         assertFalse("null", ClassUtils.isPrimitiveWrapper(null));
         assertFalse("Void.class", ClassUtils.isPrimitiveWrapper(Void.class));
@@ -832,7 +832,7 @@ public class ClassUtilsTest  {
         assertFalse("String.class", ClassUtils.isPrimitiveWrapper(String.class));
         assertFalse("this.getClass()", ClassUtils.isPrimitiveWrapper(this.getClass()));
     }
-    
+
     @Test
     public void testPrimitiveToWrapper() {
 
@@ -1127,7 +1127,7 @@ public class ClassUtilsTest  {
     public void testToClass_object() {
 //        assertNull(ClassUtils.toClass(null)); // generates warning
         assertNull(ClassUtils.toClass((Object[]) null)); // equivalent explicit cast
-        
+
         // Additional varargs tests
         assertTrue("empty -> empty", Arrays.equals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.toClass()));
         final Class<?>[] castNull = ClassUtils.toClass((Object) null); // == new Object[]{null}
@@ -1165,7 +1165,7 @@ public class ClassUtilsTest  {
         assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName(ClassUtils[][].class));
         assertEquals("int[]", ClassUtils.getShortCanonicalName(int[].class));
         assertEquals("int[][]", ClassUtils.getShortCanonicalName(int[][].class));
-        
+
         // Inner types
         class Named {}
         assertEquals("ClassUtilsTest.7", ClassUtils.getShortCanonicalName(new Object(){}.getClass()));
@@ -1184,7 +1184,7 @@ public class ClassUtilsTest  {
         assertEquals("int[][]", ClassUtils.getShortCanonicalName("[[I"));
         assertEquals("int[]", ClassUtils.getShortCanonicalName("int[]"));
         assertEquals("int[][]", ClassUtils.getShortCanonicalName("int[][]"));
-        
+
         // Inner types
         assertEquals("ClassUtilsTest.6", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtilsTest$6"));
         assertEquals("ClassUtilsTest.5Named", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtilsTest$5Named"));
@@ -1199,7 +1199,7 @@ public class ClassUtilsTest  {
         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new ClassUtils[0][0], "<null>"));
         assertEquals("", ClassUtils.getPackageCanonicalName(new int[0], "<null>"));
         assertEquals("", ClassUtils.getPackageCanonicalName(new int[0][0], "<null>"));
-        
+
         // Inner types
         class Named {}
         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Object(){}, "<null>"));
@@ -1214,7 +1214,7 @@ public class ClassUtilsTest  {
         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(ClassUtils[][].class));
         assertEquals("", ClassUtils.getPackageCanonicalName(int[].class));
         assertEquals("", ClassUtils.getPackageCanonicalName(int[][].class));
-        
+
         // Inner types
         class Named {}
         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Object(){}.getClass()));
@@ -1238,7 +1238,7 @@ public class ClassUtilsTest  {
         assertEquals("", ClassUtils.getPackageCanonicalName("[[I"));
         assertEquals("", ClassUtils.getPackageCanonicalName("int[]"));
         assertEquals("", ClassUtils.getPackageCanonicalName("int[][]"));
-        
+
         // Inner types
         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtilsTest$6"));
         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtilsTest$5Named"));

http://git-wip-us.apache.org/repos/asf/commons-lang/blob/1da8ccdb/src/test/java/org/apache/commons/lang3/EnumUtilsTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/lang3/EnumUtilsTest.java b/src/test/java/org/apache/commons/lang3/EnumUtilsTest.java
index 5845ef6..bb425d4 100644
--- a/src/test/java/org/apache/commons/lang3/EnumUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/EnumUtilsTest.java
@@ -32,7 +32,7 @@ import org.junit.Assert;
 import org.junit.Test;
 
 /**
- * 
+ *
  */
 public class EnumUtilsTest {
 
@@ -102,7 +102,7 @@ public class EnumUtilsTest {
     public void test_generateBitVectors_nullClass() {
         EnumUtils.generateBitVectors(null, EnumSet.of(Traffic.RED));
     }
-    
+
     @Test(expected=NullPointerException.class)
     public void test_generateBitVector_nullIterable() {
         EnumUtils.generateBitVector(Traffic.class, (Iterable<Traffic>) null);
@@ -112,27 +112,27 @@ public class EnumUtilsTest {
     public void test_generateBitVectors_nullIterable() {
         EnumUtils.generateBitVectors(null, (Iterable<Traffic>) null);
     }
-    
+
     @Test(expected=IllegalArgumentException.class)
     public void test_generateBitVector_nullElement() {
         EnumUtils.generateBitVector(Traffic.class, Arrays.asList(Traffic.RED, null));
     }
-    
+
     @Test(expected=IllegalArgumentException.class)
     public void test_generateBitVectors_nullElement() {
         EnumUtils.generateBitVectors(Traffic.class, Arrays.asList(Traffic.RED, null));
     }
-    
+
     @Test(expected=NullPointerException.class)
     public void test_generateBitVector_nullClassWithArray() {
         EnumUtils.generateBitVector(null, Traffic.RED);
     }
-    
+
     @Test(expected=NullPointerException.class)
     public void test_generateBitVectors_nullClassWithArray() {
         EnumUtils.generateBitVectors(null, Traffic.RED);
     }
-    
+
     @Test(expected=NullPointerException.class)
     public void test_generateBitVector_nullArray() {
         EnumUtils.generateBitVector(Traffic.class, (Traffic[]) null);
@@ -142,17 +142,17 @@ public class EnumUtilsTest {
     public void test_generateBitVectors_nullArray() {
         EnumUtils.generateBitVectors(Traffic.class, (Traffic[]) null);
     }
-    
+
     @Test(expected=IllegalArgumentException.class)
     public void test_generateBitVector_nullArrayElement() {
         EnumUtils.generateBitVector(Traffic.class, Traffic.RED, null);
     }
-    
+
     @Test(expected=IllegalArgumentException.class)
     public void test_generateBitVectors_nullArrayElement() {
         EnumUtils.generateBitVectors(Traffic.class, Traffic.RED, null);
     }
-    
+
     @Test(expected=IllegalArgumentException.class)
     public void test_generateBitVector_longClass() {
         EnumUtils.generateBitVector(TooMany.class, EnumSet.of(TooMany.A1));
@@ -174,7 +174,7 @@ public class EnumUtilsTest {
         List rawList = new ArrayList();
         EnumUtils.generateBitVector(rawType, rawList);
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test(expected=IllegalArgumentException.class)
     public void test_generateBitVectors_nonEnumClass() {
@@ -186,7 +186,7 @@ public class EnumUtilsTest {
         List rawList = new ArrayList();
         EnumUtils.generateBitVectors(rawType, rawList);
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test(expected=IllegalArgumentException.class)
     public void test_generateBitVector_nonEnumClassWithArray() {
@@ -204,7 +204,7 @@ public class EnumUtilsTest {
         Class rawType = Object.class;
         EnumUtils.generateBitVectors(rawType);
     }
-    
+
     @Test
     public void test_generateBitVector() {
         assertEquals(0L, EnumUtils.generateBitVector(Traffic.class, EnumSet.noneOf(Traffic.class)));
@@ -264,7 +264,7 @@ public class EnumUtilsTest {
         assertEquals((1L << 63), EnumUtils.generateBitVector(Enum64.class, Enum64.A63));
         assertEquals(Long.MIN_VALUE, EnumUtils.generateBitVector(Enum64.class, Enum64.A63));
     }
-    
+
     @Test
     public void test_generateBitVectorsFromArray() {
         assertArrayEquals(EnumUtils.generateBitVectors(Traffic.class), 0L);
@@ -365,7 +365,7 @@ public class EnumUtilsTest {
     public void test_processBitVector_longClass() {
         EnumUtils.processBitVector(TooMany.class, 0L);
     }
-    
+
     public void test_processBitVectors_longClass() {
         assertEquals(EnumSet.noneOf(TooMany.class), EnumUtils.processBitVectors(TooMany.class, 0L));
         assertEquals(EnumSet.of(TooMany.A), EnumUtils.processBitVectors(TooMany.class, 1L));

http://git-wip-us.apache.org/repos/asf/commons-lang/blob/1da8ccdb/src/test/java/org/apache/commons/lang3/HashSetvBitSetTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/lang3/HashSetvBitSetTest.java b/src/test/java/org/apache/commons/lang3/HashSetvBitSetTest.java
index 97fe714..5c04cd6 100644
--- a/src/test/java/org/apache/commons/lang3/HashSetvBitSetTest.java
+++ b/src/test/java/org/apache/commons/lang3/HashSetvBitSetTest.java
@@ -5,9 +5,9 @@
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -64,7 +64,7 @@ public class HashSetvBitSetTest {
         toRemove.set(10, 20);
         return (int[]) ArrayUtils.removeAll(array, toRemove);
     }
-    
+
     @Benchmark
     public int[] timeExtractRemoveAll() {
         final BitSet toRemove = new BitSet();
@@ -89,7 +89,7 @@ public class HashSetvBitSetTest {
         int i = 0;
         int j=0;
         while((j=coll.nextSetBit(j)) != -1) {
-            result[i++] = j++;            
+            result[i++] = j++;
         }
         return result;
     }

http://git-wip-us.apache.org/repos/asf/commons-lang/blob/1da8ccdb/src/test/java/org/apache/commons/lang3/LocaleUtilsTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/lang3/LocaleUtilsTest.java b/src/test/java/org/apache/commons/lang3/LocaleUtilsTest.java
index bbb93de..1c39a77 100644
--- a/src/test/java/org/apache/commons/lang3/LocaleUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/LocaleUtilsTest.java
@@ -5,9 +5,9 @@
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -49,7 +49,7 @@ public class LocaleUtilsTest  {
     private static final Locale LOCALE_FR = new Locale("fr", "");
     private static final Locale LOCALE_FR_CA = new Locale("fr", "CA");
     private static final Locale LOCALE_QQ = new Locale("qq", "");
-    private static final Locale LOCALE_QQ_ZZ = new Locale("qq", "ZZ"); 
+    private static final Locale LOCALE_QQ_ZZ = new Locale("qq", "ZZ");
 
     @Before
     public void setUp() throws Exception {
@@ -111,7 +111,7 @@ public class LocaleUtilsTest  {
      * @param variant of the resulting Locale
      */
     private static void assertValidToLocale(
-            final String localeString, final String language, 
+            final String localeString, final String language,
             final String country, final String variant) {
         final Locale locale = LocaleUtils.toLocale(localeString);
         assertNotNull("valid locale", locale);
@@ -126,7 +126,7 @@ public class LocaleUtilsTest  {
     @Test
     public void testToLocale_1Part() {
         assertNull(LocaleUtils.toLocale(null));
-        
+
         assertValidToLocale("us");
         assertValidToLocale("fr");
         assertValidToLocale("de");
@@ -152,7 +152,7 @@ public class LocaleUtilsTest  {
             LocaleUtils.toLocale("u#");
             fail("Should fail if not lowercase");
         } catch (final IllegalArgumentException iae) {}
-        
+
         try {
             LocaleUtils.toLocale("u");
             fail("Must be 2 chars if less than 5");
@@ -162,7 +162,7 @@ public class LocaleUtilsTest  {
             LocaleUtils.toLocale("uu_U");
             fail("Must be 2 chars if less than 5");
         } catch (final IllegalArgumentException iae) {}
-    }        
+    }
 
     /**
      * Test toLocale() method.
@@ -172,7 +172,7 @@ public class LocaleUtilsTest  {
         assertValidToLocale("us_EN", "us", "EN");
         //valid though doesn't exist
         assertValidToLocale("us_ZH", "us", "ZH");
-        
+
         try {
             LocaleUtils.toLocale("us-EN");
             fail("Should fail as not underscore");
@@ -197,7 +197,7 @@ public class LocaleUtilsTest  {
             LocaleUtils.toLocale("us_E3");
             fail("Should fail second part not uppercase");
         } catch (final IllegalArgumentException iae) {}
-    }        
+    }
 
     /**
      * Test toLocale() method.
@@ -214,7 +214,7 @@ public class LocaleUtilsTest  {
             assertValidToLocale("us_EN_a", "us", "EN", "A");
             assertValidToLocale("us_EN_SFsafdFDsdfF", "us", "EN", "SFSAFDFDSDFF");
         }
-        
+
         try {
             LocaleUtils.toLocale("us_EN-a");
             fail("Should fail as not underscore");
@@ -237,7 +237,7 @@ public class LocaleUtilsTest  {
         final List<Locale> localeList = defaultLocale == null ?
                 LocaleUtils.localeLookupList(locale) :
                 LocaleUtils.localeLookupList(locale, defaultLocale);
-        
+
         assertEquals(expected.length, localeList.size());
         assertEquals(Arrays.asList(expected), localeList);
         assertUnmodifiableCollection(localeList);
@@ -262,19 +262,19 @@ public class LocaleUtilsTest  {
                 LOCALE_EN_US_ZZZZ,
                 LOCALE_EN_US,
                 LOCALE_EN});
-    }        
+    }
 
     /**
      * Test localeLookupList() method.
      */
     @Test
     public void testLocaleLookupList_LocaleLocale() {
-        assertLocaleLookupList(LOCALE_QQ, LOCALE_QQ, 
+        assertLocaleLookupList(LOCALE_QQ, LOCALE_QQ,
                 new Locale[]{LOCALE_QQ});
-        assertLocaleLookupList(LOCALE_EN, LOCALE_EN, 
+        assertLocaleLookupList(LOCALE_EN, LOCALE_EN,
                 new Locale[]{LOCALE_EN});
-        
-        assertLocaleLookupList(LOCALE_EN_US, LOCALE_EN_US, 
+
+        assertLocaleLookupList(LOCALE_EN_US, LOCALE_EN_US,
             new Locale[]{
                 LOCALE_EN_US,
                 LOCALE_EN});
@@ -288,7 +288,7 @@ public class LocaleUtilsTest  {
                 LOCALE_EN_US,
                 LOCALE_EN,
                 LOCALE_QQ_ZZ});
-        
+
         assertLocaleLookupList(LOCALE_EN_US_ZZZZ, null,
             new Locale[] {
                 LOCALE_EN_US_ZZZZ,
@@ -329,7 +329,7 @@ public class LocaleUtilsTest  {
         assertNotNull(list);
         assertSame(list, list2);
         assertUnmodifiableCollection(list);
-        
+
         final Locale[] jdkLocaleArray = Locale.getAvailableLocales();
         final List<Locale> jdkLocaleList = Arrays.asList(jdkLocaleArray);
         assertEquals(jdkLocaleList, list);
@@ -346,7 +346,7 @@ public class LocaleUtilsTest  {
         assertNotNull(set);
         assertSame(set, set2);
         assertUnmodifiableCollection(set);
-        
+
         final Locale[] jdkLocaleArray = Locale.getAvailableLocales();
         final List<Locale> jdkLocaleList = Arrays.asList(jdkLocaleArray);
         final Set<Locale> jdkLocaleSet = new HashSet<>(jdkLocaleList);
@@ -369,10 +369,10 @@ public class LocaleUtilsTest  {
         assertEquals(set.contains(LOCALE_QQ), LocaleUtils.isAvailableLocale(LOCALE_QQ));
         assertEquals(set.contains(LOCALE_QQ_ZZ), LocaleUtils.isAvailableLocale(LOCALE_QQ_ZZ));
     }
-    
+
     /**
      * Test for 3-chars locale, further details at LANG-915
-     * 
+     *
      */
     @Test
     public void testThreeCharsLocale() {
@@ -387,9 +387,9 @@ public class LocaleUtilsTest  {
 
     //-----------------------------------------------------------------------
     /**
-     * Make sure the language by country is correct. It checks that 
-     * the LocaleUtils.languagesByCountry(country) call contains the 
-     * array of languages passed in. It may contain more due to JVM 
+     * Make sure the language by country is correct. It checks that
+     * the LocaleUtils.languagesByCountry(country) call contains the
+     * array of languages passed in. It may contain more due to JVM
      * variations.
      *
      * @param country
@@ -437,9 +437,9 @@ public class LocaleUtilsTest  {
 
     //-----------------------------------------------------------------------
     /**
-     * Make sure the country by language is correct. It checks that 
-     * the LocaleUtils.countryByLanguage(language) call contains the 
-     * array of countries passed in. It may contain more due to JVM 
+     * Make sure the country by language is correct. It checks that
+     * the LocaleUtils.countryByLanguage(language) call contains the
+     * array of countries passed in. It may contain more due to JVM
      * variations.
      *
      *

http://git-wip-us.apache.org/repos/asf/commons-lang/blob/1da8ccdb/src/test/java/org/apache/commons/lang3/NotImplementedExceptionTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/lang3/NotImplementedExceptionTest.java b/src/test/java/org/apache/commons/lang3/NotImplementedExceptionTest.java
index ff422ae..86f4fab 100644
--- a/src/test/java/org/apache/commons/lang3/NotImplementedExceptionTest.java
+++ b/src/test/java/org/apache/commons/lang3/NotImplementedExceptionTest.java
@@ -5,9 +5,9 @@
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.


Mime
View raw message