commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From aherb...@apache.org
Subject [commons-collections] 05/07: Add indentation check to checkstyle.
Date Mon, 24 Feb 2020 22:42:31 GMT
This is an automated email from the ASF dual-hosted git repository.

aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-collections.git

commit 3aa817726b845666460f7f3ce342aa0c273ffbc5
Author: aherbert <a.herbert@sussex.ac.uk>
AuthorDate: Wed Feb 19 11:15:09 2020 +0000

    Add indentation check to checkstyle.
    
    Fixed all code. Case statements have an indent of zero as recommended by
    Oracle. Previously the code was using either 0 or 4 as the indent. Using
    zero for the check has fewer violations that require fixing.
---
 src/conf/checkstyle.xml                            |   4 +
 .../commons/collections4/CollectionUtils.java      |   2 +-
 .../org/apache/commons/collections4/ListUtils.java |   2 +-
 .../commons/collections4/bidimap/TreeBidiMap.java  |   4 +-
 .../bloomfilter/hasher/HashFunctionIdentity.java   |   6 +-
 .../collection/CompositeCollection.java            |   4 +-
 .../collections4/functors/AndPredicate.java        |   2 +-
 .../commons/collections4/functors/OrPredicate.java |   2 +-
 .../apache/commons/collections4/list/TreeList.java |  32 +-
 .../collections4/map/AbstractHashedMap.java        |   4 +-
 .../commons/collections4/map/DefaultedMap.java     |   4 +-
 .../apache/commons/collections4/map/Flat3Map.java  | 582 ++++++++++-----------
 .../apache/commons/collections4/map/LRUMap.java    |   2 +-
 .../commons/collections4/map/SingletonMap.java     |  16 +-
 .../multimap/AbstractMultiValuedMap.java           |  50 +-
 .../collections4/multiset/AbstractMultiSet.java    |  25 +-
 .../org/apache/commons/collections4/overview.html  |  24 +-
 .../commons/collections4/set/CompositeSet.java     |   4 +-
 .../collections4/trie/AbstractPatriciaTrie.java    | 232 ++++----
 .../trie/analyzer/StringKeyAnalyzer.java           |   4 +-
 .../org/apache/commons/collections4/BulkTest.java  |  26 +-
 .../commons/collections4/ClosureUtilsTest.java     |   4 +-
 .../commons/collections4/EnumerationUtilsTest.java |   6 +-
 .../commons/collections4/FactoryUtilsTest.java     |   2 +-
 .../apache/commons/collections4/ListUtilsTest.java |  48 +-
 .../apache/commons/collections4/MapUtilsTest.java  |  44 +-
 .../commons/collections4/PredicateUtilsTest.java   |  11 +-
 .../commons/collections4/TransformerUtilsTest.java |   9 +-
 .../collections4/bag/AbstractSortedBagTest.java    |   2 +-
 .../collections4/bag/PredicatedBagTest.java        |   2 +-
 .../collection/AbstractCollectionTest.java         |   4 +-
 .../collection/CompositeCollectionTest.java        |   2 +-
 .../collection/PredicatedCollectionTest.java       |   2 +-
 .../comparators/TransformingComparatorTest.java    |   4 +-
 .../collections4/functors/EqualPredicateTest.java  |   2 +-
 .../iterators/CollatingIteratorTest.java           |  88 ++--
 .../iterators/SingletonListIteratorTest.java       |   8 +-
 .../iterators/ZippingIteratorTest.java             |  56 +-
 .../collections4/list/AbstractLinkedListTest.java  |   2 +-
 .../collections4/list/AbstractListTest.java        | 491 +++++++++--------
 .../list/CursorableLinkedListTest.java             |  16 +-
 .../collections4/list/PredicatedListTest.java      |  27 +-
 .../collections4/list/SetUniqueListTest.java       |  78 +--
 .../collections4/list/UnmodifiableListTest.java    |  18 +-
 .../commons/collections4/map/CompositeMapTest.java | 124 ++---
 .../commons/collections4/map/DefaultedMapTest.java |  76 +--
 .../commons/collections4/map/EmptyMapMutator.java  |   6 +-
 .../collections4/map/LazySortedMapTest.java        |   2 +-
 .../commons/collections4/map/MultiKeyMapTest.java  |  40 +-
 .../collections4/map/MultiValueMapTest.java        |   3 +-
 .../collections4/map/PredicatedSortedMapTest.java  |   4 +-
 .../commons/collections4/map/ReferenceMapTest.java |   3 +-
 .../multimap/AbstractMultiValuedMapTest.java       |  14 +-
 .../org/apache/commons/collections4/overview.html  |  24 +-
 .../collections4/queue/PredicatedQueueTest.java    |   3 +-
 .../collections4/set/AbstractNavigableSetTest.java |  22 +-
 .../collections4/set/AbstractSortedSetTest.java    |  24 +-
 .../set/PredicatedNavigableSetTest.java            |   3 +-
 .../collections4/set/PredicatedSetTest.java        |  15 +-
 .../collections4/set/PredicatedSortedSetTest.java  |   3 +-
 .../splitmap/TransformedSplitMapTest.java          |   2 +-
 .../collections4/trie/PatriciaTrieTest.java        |  18 +-
 62 files changed, 1160 insertions(+), 1183 deletions(-)

diff --git a/src/conf/checkstyle.xml b/src/conf/checkstyle.xml
index 3079b6b..04d0fd1 100644
--- a/src/conf/checkstyle.xml
+++ b/src/conf/checkstyle.xml
@@ -59,5 +59,9 @@ limitations under the License.
     <module name="GenericWhitespace"/>
     <module name="WhitespaceAfter"/>
     <module name="NoWhitespaceBefore"/>
+    <module name="Indentation">
+      <!-- Indentation style recommended by Oracle -->
+      <property name="caseIndent" value="0"/>
+    </module>
  </module>
 </module>
diff --git a/src/main/java/org/apache/commons/collections4/CollectionUtils.java b/src/main/java/org/apache/commons/collections4/CollectionUtils.java
index 6b60b6c..9395dc8 100644
--- a/src/main/java/org/apache/commons/collections4/CollectionUtils.java
+++ b/src/main/java/org/apache/commons/collections4/CollectionUtils.java
@@ -1870,7 +1870,7 @@ public class CollectionUtils {
      */
     public static <E> Collection<E> removeAll(final Collection<E> collection, final Collection<?> remove) {
         return ListUtils.removeAll(collection, remove);
-  }
+    }
 
     /**
      * Removes all elements in {@code remove} from {@code collection}.
diff --git a/src/main/java/org/apache/commons/collections4/ListUtils.java b/src/main/java/org/apache/commons/collections4/ListUtils.java
index fa3ef9e..30ce1ce 100644
--- a/src/main/java/org/apache/commons/collections4/ListUtils.java
+++ b/src/main/java/org/apache/commons/collections4/ListUtils.java
@@ -554,7 +554,7 @@ public class ListUtils {
      * @since 4.0
      */
     public static <E> List<E> longestCommonSubsequence(final List<E> a, final List<E> b) {
-      return longestCommonSubsequence( a, b, DefaultEquator.defaultEquator() );
+        return longestCommonSubsequence( a, b, DefaultEquator.defaultEquator() );
     }
 
     /**
diff --git a/src/main/java/org/apache/commons/collections4/bidimap/TreeBidiMap.java b/src/main/java/org/apache/commons/collections4/bidimap/TreeBidiMap.java
index 7af7f2c..ff3a410 100644
--- a/src/main/java/org/apache/commons/collections4/bidimap/TreeBidiMap.java
+++ b/src/main/java/org/apache/commons/collections4/bidimap/TreeBidiMap.java
@@ -1429,8 +1429,8 @@ public class TreeBidiMap<K extends Comparable<K>, V extends Comparable<V>>
             final Object key = it.next();
             final Object value = it.getValue();
             buf.append(key == this ? "(this Map)" : key)
-               .append('=')
-               .append(value == this ? "(this Map)" : value);
+                .append('=')
+                .append(value == this ? "(this Map)" : value);
 
             hasNext = it.hasNext();
             if (hasNext) {
diff --git a/src/main/java/org/apache/commons/collections4/bloomfilter/hasher/HashFunctionIdentity.java b/src/main/java/org/apache/commons/collections4/bloomfilter/hasher/HashFunctionIdentity.java
index 13ed43f..0047ad1 100644
--- a/src/main/java/org/apache/commons/collections4/bloomfilter/hasher/HashFunctionIdentity.java
+++ b/src/main/java/org/apache/commons/collections4/bloomfilter/hasher/HashFunctionIdentity.java
@@ -84,9 +84,9 @@ public interface HashFunctionIdentity {
      * @return the signature buffer for the identity
      */
     static byte[] prepareSignatureBuffer(final HashFunctionIdentity identity) {
-       return String.format("%s-%s-%s",
-           identity.getName().toUpperCase(Locale.ROOT), identity.getSignedness(),
-           identity.getProcessType()).getBytes(StandardCharsets.UTF_8);
+        return String.format("%s-%s-%s",
+            identity.getName().toUpperCase(Locale.ROOT), identity.getSignedness(),
+            identity.getProcessType()).getBytes(StandardCharsets.UTF_8);
     }
 
     /**
diff --git a/src/main/java/org/apache/commons/collections4/collection/CompositeCollection.java b/src/main/java/org/apache/commons/collections4/collection/CompositeCollection.java
index cd6d4fe..23641a7 100644
--- a/src/main/java/org/apache/commons/collections4/collection/CompositeCollection.java
+++ b/src/main/java/org/apache/commons/collections4/collection/CompositeCollection.java
@@ -225,8 +225,8 @@ public class CompositeCollection<E> implements Collection<E>, Serializable {
     @Override
     public boolean add(final E obj) {
         if (mutator == null) {
-           throw new UnsupportedOperationException(
-               "add() is not supported on CompositeCollection without a CollectionMutator strategy");
+            throw new UnsupportedOperationException(
+                "add() is not supported on CompositeCollection without a CollectionMutator strategy");
         }
         return mutator.add(this, all, obj);
     }
diff --git a/src/main/java/org/apache/commons/collections4/functors/AndPredicate.java b/src/main/java/org/apache/commons/collections4/functors/AndPredicate.java
index 0c14cf2..af96f92 100644
--- a/src/main/java/org/apache/commons/collections4/functors/AndPredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/AndPredicate.java
@@ -72,7 +72,7 @@ public final class AndPredicate<T> implements PredicateDecorator<T>, Serializabl
      */
     @Override
     public boolean evaluate(final T object) {
-       return iPredicate1.evaluate(object) && iPredicate2.evaluate(object);
+        return iPredicate1.evaluate(object) && iPredicate2.evaluate(object);
     }
 
     /**
diff --git a/src/main/java/org/apache/commons/collections4/functors/OrPredicate.java b/src/main/java/org/apache/commons/collections4/functors/OrPredicate.java
index c2642b6..efde40c 100644
--- a/src/main/java/org/apache/commons/collections4/functors/OrPredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/OrPredicate.java
@@ -72,7 +72,7 @@ public final class OrPredicate<T> implements PredicateDecorator<T>, Serializable
      */
     @Override
     public boolean evaluate(final T object) {
-       return iPredicate1.evaluate(object) || iPredicate2.evaluate(object);
+        return iPredicate1.evaluate(object) || iPredicate2.evaluate(object);
     }
 
     /**
diff --git a/src/main/java/org/apache/commons/collections4/list/TreeList.java b/src/main/java/org/apache/commons/collections4/list/TreeList.java
index 90d3be5..75515ee 100644
--- a/src/main/java/org/apache/commons/collections4/list/TreeList.java
+++ b/src/main/java/org/apache/commons/collections4/list/TreeList.java
@@ -679,22 +679,22 @@ public class TreeList<E> extends AbstractList<E> {
          */
         private AVLNode<E> balance() {
             switch (heightRightMinusLeft()) {
-                case 1 :
-                case 0 :
-                case -1 :
-                    return this;
-                case -2 :
-                    if (left.heightRightMinusLeft() > 0) {
-                        setLeft(left.rotateLeft(), null);
-                    }
-                    return rotateRight();
-                case 2 :
-                    if (right.heightRightMinusLeft() < 0) {
-                        setRight(right.rotateRight(), null);
-                    }
-                    return rotateLeft();
-                default :
-                    throw new RuntimeException("tree inconsistent!");
+            case 1 :
+            case 0 :
+            case -1 :
+                return this;
+            case -2 :
+                if (left.heightRightMinusLeft() > 0) {
+                    setLeft(left.rotateLeft(), null);
+                }
+                return rotateRight();
+            case 2 :
+                if (right.heightRightMinusLeft() < 0) {
+                    setRight(right.rotateRight(), null);
+                }
+                return rotateLeft();
+            default :
+                throw new RuntimeException("tree inconsistent!");
             }
         }
 
diff --git a/src/main/java/org/apache/commons/collections4/map/AbstractHashedMap.java b/src/main/java/org/apache/commons/collections4/map/AbstractHashedMap.java
index a9bdb39..f0fa69e 100644
--- a/src/main/java/org/apache/commons/collections4/map/AbstractHashedMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/AbstractHashedMap.java
@@ -1410,8 +1410,8 @@ public class AbstractHashedMap<K, V> extends AbstractMap<K, V> implements Iterab
             final K key = it.next();
             final V value = it.getValue();
             buf.append(key == this ? "(this Map)" : key)
-               .append('=')
-               .append(value == this ? "(this Map)" : value);
+                .append('=')
+                .append(value == this ? "(this Map)" : value);
 
             hasNext = it.hasNext();
             if (hasNext) {
diff --git a/src/main/java/org/apache/commons/collections4/map/DefaultedMap.java b/src/main/java/org/apache/commons/collections4/map/DefaultedMap.java
index 6fda447..a40dd8d 100644
--- a/src/main/java/org/apache/commons/collections4/map/DefaultedMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/DefaultedMap.java
@@ -200,8 +200,8 @@ public class DefaultedMap<K, V> extends AbstractMapDecorator<K, V> implements Se
     public V get(final Object key) {
         V v;
         return (((v = map.get(key)) != null) || map.containsKey(key))
-          ? v
-          : value.transform((K) key);
+            ? v
+            : value.transform((K) key);
     }
 
     // no need to wrap keySet, entrySet or values as they are views of
diff --git a/src/main/java/org/apache/commons/collections4/map/Flat3Map.java b/src/main/java/org/apache/commons/collections4/map/Flat3Map.java
index 4be81a7..603b566 100644
--- a/src/main/java/org/apache/commons/collections4/map/Flat3Map.java
+++ b/src/main/java/org/apache/commons/collections4/map/Flat3Map.java
@@ -138,37 +138,37 @@ public class Flat3Map<K, V> implements IterableMap<K, V>, Serializable, Cloneabl
         }
         if (key == null) {
             switch (size) {
+            // drop through
+            case 3:
+                if (key3 == null) {
+                    return value3;
+                }
+            case 2:
+                if (key2 == null) {
+                    return value2;
+                }
+            case 1:
+                if (key1 == null) {
+                    return value1;
+                }
+            }
+        } else {
+            if (size > 0) {
+                final int hashCode = key.hashCode();
+                switch (size) {
                 // drop through
                 case 3:
-                    if (key3 == null) {
+                    if (hash3 == hashCode && key.equals(key3)) {
                         return value3;
                     }
                 case 2:
-                    if (key2 == null) {
+                    if (hash2 == hashCode && key.equals(key2)) {
                         return value2;
                     }
                 case 1:
-                    if (key1 == null) {
+                    if (hash1 == hashCode && key.equals(key1)) {
                         return value1;
                     }
-            }
-        } else {
-            if (size > 0) {
-                final int hashCode = key.hashCode();
-                switch (size) {
-                    // drop through
-                    case 3:
-                        if (hash3 == hashCode && key.equals(key3)) {
-                            return value3;
-                        }
-                    case 2:
-                        if (hash2 == hashCode && key.equals(key2)) {
-                            return value2;
-                        }
-                    case 1:
-                        if (hash1 == hashCode && key.equals(key1)) {
-                            return value1;
-                        }
                 }
             }
         }
@@ -212,35 +212,35 @@ public class Flat3Map<K, V> implements IterableMap<K, V>, Serializable, Cloneabl
         }
         if (key == null) {
             switch (size) {  // drop through
+            case 3:
+                if (key3 == null) {
+                    return true;
+                }
+            case 2:
+                if (key2 == null) {
+                    return true;
+                }
+            case 1:
+                if (key1 == null) {
+                    return true;
+                }
+            }
+        } else {
+            if (size > 0) {
+                final int hashCode = key.hashCode();
+                switch (size) {  // drop through
                 case 3:
-                    if (key3 == null) {
+                    if (hash3 == hashCode && key.equals(key3)) {
                         return true;
                     }
                 case 2:
-                    if (key2 == null) {
+                    if (hash2 == hashCode && key.equals(key2)) {
                         return true;
                     }
                 case 1:
-                    if (key1 == null) {
+                    if (hash1 == hashCode && key.equals(key1)) {
                         return true;
                     }
-            }
-        } else {
-            if (size > 0) {
-                final int hashCode = key.hashCode();
-                switch (size) {  // drop through
-                    case 3:
-                        if (hash3 == hashCode && key.equals(key3)) {
-                            return true;
-                        }
-                    case 2:
-                        if (hash2 == hashCode && key.equals(key2)) {
-                            return true;
-                        }
-                    case 1:
-                        if (hash1 == hashCode && key.equals(key1)) {
-                            return true;
-                        }
                 }
             }
         }
@@ -260,33 +260,33 @@ public class Flat3Map<K, V> implements IterableMap<K, V>, Serializable, Cloneabl
         }
         if (value == null) {  // drop through
             switch (size) {
-                case 3:
-                    if (value3 == null) {
-                        return true;
-                    }
-                case 2:
-                    if (value2 == null) {
-                        return true;
-                    }
-                case 1:
-                    if (value1 == null) {
-                        return true;
-                    }
+            case 3:
+                if (value3 == null) {
+                    return true;
+                }
+            case 2:
+                if (value2 == null) {
+                    return true;
+                }
+            case 1:
+                if (value1 == null) {
+                    return true;
+                }
             }
         } else {
             switch (size) {  // drop through
-                case 3:
-                    if (value.equals(value3)) {
-                        return true;
-                    }
-                case 2:
-                    if (value.equals(value2)) {
-                        return true;
-                    }
-                case 1:
-                    if (value.equals(value1)) {
-                        return true;
-                    }
+            case 3:
+                if (value.equals(value3)) {
+                    return true;
+                }
+            case 2:
+                if (value.equals(value2)) {
+                    return true;
+                }
+            case 1:
+                if (value.equals(value1)) {
+                    return true;
+                }
             }
         }
         return false;
@@ -308,72 +308,72 @@ public class Flat3Map<K, V> implements IterableMap<K, V>, Serializable, Cloneabl
         // change existing mapping
         if (key == null) {
             switch (size) {  // drop through
+            case 3:
+                if (key3 == null) {
+                    final V old = value3;
+                    value3 = value;
+                    return old;
+                }
+            case 2:
+                if (key2 == null) {
+                    final V old = value2;
+                    value2 = value;
+                    return old;
+                }
+            case 1:
+                if (key1 == null) {
+                    final V old = value1;
+                    value1 = value;
+                    return old;
+                }
+            }
+        } else {
+            if (size > 0) {
+                final int hashCode = key.hashCode();
+                switch (size) {  // drop through
                 case 3:
-                    if (key3 == null) {
+                    if (hash3 == hashCode && key.equals(key3)) {
                         final V old = value3;
                         value3 = value;
                         return old;
                     }
                 case 2:
-                    if (key2 == null) {
+                    if (hash2 == hashCode && key.equals(key2)) {
                         final V old = value2;
                         value2 = value;
                         return old;
                     }
                 case 1:
-                    if (key1 == null) {
+                    if (hash1 == hashCode && key.equals(key1)) {
                         final V old = value1;
                         value1 = value;
                         return old;
                     }
-            }
-        } else {
-            if (size > 0) {
-                final int hashCode = key.hashCode();
-                switch (size) {  // drop through
-                    case 3:
-                        if (hash3 == hashCode && key.equals(key3)) {
-                            final V old = value3;
-                            value3 = value;
-                            return old;
-                        }
-                    case 2:
-                        if (hash2 == hashCode && key.equals(key2)) {
-                            final V old = value2;
-                            value2 = value;
-                            return old;
-                        }
-                    case 1:
-                        if (hash1 == hashCode && key.equals(key1)) {
-                            final V old = value1;
-                            value1 = value;
-                            return old;
-                        }
                 }
             }
         }
 
         // add new mapping
         switch (size) {
-            default:
-                convertToMap();
-                delegateMap.put(key, value);
-                return null;
-            case 2:
-                hash3 = key == null ? 0 : key.hashCode();
-                key3 = key;
-                value3 = value;
-                break;
-            case 1:
-                hash2 = key == null ? 0 : key.hashCode();
-                key2 = key;
-                value2 = value;
-                break;
-            case 0:
-                hash1 = key == null ? 0 : key.hashCode();
-                key1 = key;
-                value1 = value;
-                break;
+        default:
+            convertToMap();
+            delegateMap.put(key, value);
+            return null;
+        case 2:
+            hash3 = key == null ? 0 : key.hashCode();
+            key3 = key;
+            value3 = value;
+            break;
+        case 1:
+            hash2 = key == null ? 0 : key.hashCode();
+            key2 = key;
+            value2 = value;
+            break;
+        case 0:
+            hash1 = key == null ? 0 : key.hashCode();
+            key1 = key;
+            value1 = value;
+            break;
         }
         size++;
         return null;
@@ -411,16 +411,16 @@ public class Flat3Map<K, V> implements IterableMap<K, V>, Serializable, Cloneabl
     private void convertToMap() {
         delegateMap = createDelegateMap();
         switch (size) {  // drop through
-            case 3:
-                delegateMap.put(key3, value3);
-            case 2:
-                delegateMap.put(key2, value2);
-            case 1:
-                delegateMap.put(key1, value1);
-            case 0:
-                break;
-            default:
-                throw new IllegalStateException("Invalid map index: " + size);
+        case 3:
+            delegateMap.put(key3, value3);
+        case 2:
+            delegateMap.put(key2, value2);
+        case 1:
+            delegateMap.put(key1, value1);
+        case 0:
+            break;
+        default:
+            throw new IllegalStateException("Invalid map index: " + size);
         }
 
         size = 0;
@@ -459,8 +459,75 @@ public class Flat3Map<K, V> implements IterableMap<K, V>, Serializable, Cloneabl
         }
         if (key == null) {
             switch (size) {  // drop through
+            case 3:
+                if (key3 == null) {
+                    final V old = value3;
+                    hash3 = 0;
+                    key3 = null;
+                    value3 = null;
+                    size = 2;
+                    return old;
+                }
+                if (key2 == null) {
+                    final V old = value2;
+                    hash2 = hash3;
+                    key2 = key3;
+                    value2 = value3;
+                    hash3 = 0;
+                    key3 = null;
+                    value3 = null;
+                    size = 2;
+                    return old;
+                }
+                if (key1 == null) {
+                    final V old = value1;
+                    hash1 = hash3;
+                    key1 = key3;
+                    value1 = value3;
+                    hash3 = 0;
+                    key3 = null;
+                    value3 = null;
+                    size = 2;
+                    return old;
+                }
+                return null;
+            case 2:
+                if (key2 == null) {
+                    final V old = value2;
+                    hash2 = 0;
+                    key2 = null;
+                    value2 = null;
+                    size = 1;
+                    return old;
+                }
+                if (key1 == null) {
+                    final V old = value1;
+                    hash1 = hash2;
+                    key1 = key2;
+                    value1 = value2;
+                    hash2 = 0;
+                    key2 = null;
+                    value2 = null;
+                    size = 1;
+                    return old;
+                }
+                return null;
+            case 1:
+                if (key1 == null) {
+                    final V old = value1;
+                    hash1 = 0;
+                    key1 = null;
+                    value1 = null;
+                    size = 0;
+                    return old;
+                }
+            }
+        } else {
+            if (size > 0) {
+                final int hashCode = key.hashCode();
+                switch (size) {  // drop through
                 case 3:
-                    if (key3 == null) {
+                    if (hash3 == hashCode && key.equals(key3)) {
                         final V old = value3;
                         hash3 = 0;
                         key3 = null;
@@ -468,7 +535,7 @@ public class Flat3Map<K, V> implements IterableMap<K, V>, Serializable, Cloneabl
                         size = 2;
                         return old;
                     }
-                    if (key2 == null) {
+                    if (hash2 == hashCode && key.equals(key2)) {
                         final V old = value2;
                         hash2 = hash3;
                         key2 = key3;
@@ -479,7 +546,7 @@ public class Flat3Map<K, V> implements IterableMap<K, V>, Serializable, Cloneabl
                         size = 2;
                         return old;
                     }
-                    if (key1 == null) {
+                    if (hash1 == hashCode && key.equals(key1)) {
                         final V old = value1;
                         hash1 = hash3;
                         key1 = key3;
@@ -492,7 +559,7 @@ public class Flat3Map<K, V> implements IterableMap<K, V>, Serializable, Cloneabl
                     }
                     return null;
                 case 2:
-                    if (key2 == null) {
+                    if (hash2 == hashCode && key.equals(key2)) {
                         final V old = value2;
                         hash2 = 0;
                         key2 = null;
@@ -500,7 +567,7 @@ public class Flat3Map<K, V> implements IterableMap<K, V>, Serializable, Cloneabl
                         size = 1;
                         return old;
                     }
-                    if (key1 == null) {
+                    if (hash1 == hashCode && key.equals(key1)) {
                         final V old = value1;
                         hash1 = hash2;
                         key1 = key2;
@@ -513,7 +580,7 @@ public class Flat3Map<K, V> implements IterableMap<K, V>, Serializable, Cloneabl
                     }
                     return null;
                 case 1:
-                    if (key1 == null) {
+                    if (hash1 == hashCode && key.equals(key1)) {
                         final V old = value1;
                         hash1 = 0;
                         key1 = null;
@@ -521,73 +588,6 @@ public class Flat3Map<K, V> implements IterableMap<K, V>, Serializable, Cloneabl
                         size = 0;
                         return old;
                     }
-            }
-        } else {
-            if (size > 0) {
-                final int hashCode = key.hashCode();
-                switch (size) {  // drop through
-                    case 3:
-                        if (hash3 == hashCode && key.equals(key3)) {
-                            final V old = value3;
-                            hash3 = 0;
-                            key3 = null;
-                            value3 = null;
-                            size = 2;
-                            return old;
-                        }
-                        if (hash2 == hashCode && key.equals(key2)) {
-                            final V old = value2;
-                            hash2 = hash3;
-                            key2 = key3;
-                            value2 = value3;
-                            hash3 = 0;
-                            key3 = null;
-                            value3 = null;
-                            size = 2;
-                            return old;
-                        }
-                        if (hash1 == hashCode && key.equals(key1)) {
-                            final V old = value1;
-                            hash1 = hash3;
-                            key1 = key3;
-                            value1 = value3;
-                            hash3 = 0;
-                            key3 = null;
-                            value3 = null;
-                            size = 2;
-                            return old;
-                        }
-                        return null;
-                    case 2:
-                        if (hash2 == hashCode && key.equals(key2)) {
-                            final V old = value2;
-                            hash2 = 0;
-                            key2 = null;
-                            value2 = null;
-                            size = 1;
-                            return old;
-                        }
-                        if (hash1 == hashCode && key.equals(key1)) {
-                            final V old = value1;
-                            hash1 = hash2;
-                            key1 = key2;
-                            value1 = value2;
-                            hash2 = 0;
-                            key2 = null;
-                            value2 = null;
-                            size = 1;
-                            return old;
-                        }
-                        return null;
-                    case 1:
-                        if (hash1 == hashCode && key.equals(key1)) {
-                            final V old = value1;
-                            hash1 = 0;
-                            key1 = null;
-                            value1 = null;
-                            size = 0;
-                            return old;
-                        }
                 }
             }
         }
@@ -678,12 +678,12 @@ public class Flat3Map<K, V> implements IterableMap<K, V>, Serializable, Cloneabl
                 throw new IllegalStateException(AbstractHashedMap.GETKEY_INVALID);
             }
             switch (nextIndex) {
-                case 3:
-                    return parent.key3;
-                case 2:
-                    return parent.key2;
-                case 1:
-                    return parent.key1;
+            case 3:
+                return parent.key3;
+            case 2:
+                return parent.key2;
+            case 1:
+                return parent.key1;
             }
             throw new IllegalStateException("Invalid map index: " + nextIndex);
         }
@@ -694,12 +694,12 @@ public class Flat3Map<K, V> implements IterableMap<K, V>, Serializable, Cloneabl
                 throw new IllegalStateException(AbstractHashedMap.GETVALUE_INVALID);
             }
             switch (nextIndex) {
-                case 3:
-                    return parent.value3;
-                case 2:
-                    return parent.value2;
-                case 1:
-                    return parent.value1;
+            case 3:
+                return parent.value3;
+            case 2:
+                return parent.value2;
+            case 1:
+                return parent.value1;
             }
             throw new IllegalStateException("Invalid map index: " + nextIndex);
         }
@@ -711,17 +711,17 @@ public class Flat3Map<K, V> implements IterableMap<K, V>, Serializable, Cloneabl
             }
             final V old = getValue();
             switch (nextIndex) {
-                case 3:
-                    parent.value3 = value;
-                    break;
-                case 2:
-                    parent.value2 = value;
-                    break;
-                case 1:
-                    parent.value1 = value;
-                    break;
-                default:
-                    throw new IllegalStateException("Invalid map index: " + nextIndex);
+            case 3:
+                parent.value3 = value;
+                break;
+            case 2:
+                parent.value2 = value;
+                break;
+            case 1:
+                parent.value1 = value;
+                break;
+            default:
+                throw new IllegalStateException("Invalid map index: " + nextIndex);
             }
             return old;
         }
@@ -834,12 +834,12 @@ public class Flat3Map<K, V> implements IterableMap<K, V>, Serializable, Cloneabl
                 throw new IllegalStateException(AbstractHashedMap.GETKEY_INVALID);
             }
             switch (index) {
-                case 3:
-                    return parent.key3;
-                case 2:
-                    return parent.key2;
-                case 1:
-                    return parent.key1;
+            case 3:
+                return parent.key3;
+            case 2:
+                return parent.key2;
+            case 1:
+                return parent.key1;
             }
             throw new IllegalStateException("Invalid map index: " + index);
         }
@@ -850,12 +850,12 @@ public class Flat3Map<K, V> implements IterableMap<K, V>, Serializable, Cloneabl
                 throw new IllegalStateException(AbstractHashedMap.GETVALUE_INVALID);
             }
             switch (index) {
-                case 3:
-                    return parent.value3;
-                case 2:
-                    return parent.value2;
-                case 1:
-                    return parent.value1;
+            case 3:
+                return parent.value3;
+            case 2:
+                return parent.value2;
+            case 1:
+                return parent.value1;
             }
             throw new IllegalStateException("Invalid map index: " + index);
         }
@@ -867,17 +867,17 @@ public class Flat3Map<K, V> implements IterableMap<K, V>, Serializable, Cloneabl
             }
             final V old = getValue();
             switch (index) {
-                case 3:
-                    parent.value3 = value;
-                    break;
-                case 2:
-                    parent.value2 = value;
-                    break;
-                case 1:
-                    parent.value1 = value;
-                    break;
-                default:
-                    throw new IllegalStateException("Invalid map index: " + index);
+            case 3:
+                parent.value3 = value;
+                break;
+            case 2:
+                parent.value2 = value;
+                break;
+            case 1:
+                parent.value1 = value;
+                break;
+            default:
+                throw new IllegalStateException("Invalid map index: " + index);
             }
             return old;
         }
@@ -1193,30 +1193,30 @@ public class Flat3Map<K, V> implements IterableMap<K, V>, Serializable, Cloneabl
         if (size > 0) {
             Object otherValue = null;
             switch (size) {  // drop through
-                case 3:
-                    if (other.containsKey(key3) == false) {
-                        return false;
-                    }
-                    otherValue = other.get(key3);
-                    if (value3 == null ? otherValue != null : !value3.equals(otherValue)) {
-                        return false;
-                    }
-                case 2:
-                    if (other.containsKey(key2) == false) {
-                        return false;
-                    }
-                    otherValue = other.get(key2);
-                    if (value2 == null ? otherValue != null : !value2.equals(otherValue)) {
-                        return false;
-                    }
-                case 1:
-                    if (other.containsKey(key1) == false) {
-                        return false;
-                    }
-                    otherValue = other.get(key1);
-                    if (value1 == null ? otherValue != null : !value1.equals(otherValue)) {
-                        return false;
-                    }
+            case 3:
+                if (other.containsKey(key3) == false) {
+                    return false;
+                }
+                otherValue = other.get(key3);
+                if (value3 == null ? otherValue != null : !value3.equals(otherValue)) {
+                    return false;
+                }
+            case 2:
+                if (other.containsKey(key2) == false) {
+                    return false;
+                }
+                otherValue = other.get(key2);
+                if (value2 == null ? otherValue != null : !value2.equals(otherValue)) {
+                    return false;
+                }
+            case 1:
+                if (other.containsKey(key1) == false) {
+                    return false;
+                }
+                otherValue = other.get(key1);
+                if (value1 == null ? otherValue != null : !value1.equals(otherValue)) {
+                    return false;
+                }
             }
         }
         return true;
@@ -1234,16 +1234,16 @@ public class Flat3Map<K, V> implements IterableMap<K, V>, Serializable, Cloneabl
         }
         int total = 0;
         switch (size) {  // drop through
-            case 3:
-                total += hash3 ^ (value3 == null ? 0 : value3.hashCode());
-            case 2:
-                total += hash2 ^ (value2 == null ? 0 : value2.hashCode());
-            case 1:
-                total += hash1 ^ (value1 == null ? 0 : value1.hashCode());
-            case 0:
-                break;
-            default:
-                throw new IllegalStateException("Invalid map index: " + size);
+        case 3:
+            total += hash3 ^ (value3 == null ? 0 : value3.hashCode());
+        case 2:
+            total += hash2 ^ (value2 == null ? 0 : value2.hashCode());
+        case 1:
+            total += hash1 ^ (value1 == null ? 0 : value1.hashCode());
+        case 0:
+            break;
+        default:
+            throw new IllegalStateException("Invalid map index: " + size);
         }
         return total;
     }
@@ -1264,24 +1264,24 @@ public class Flat3Map<K, V> implements IterableMap<K, V>, Serializable, Cloneabl
         final StringBuilder buf = new StringBuilder(128);
         buf.append('{');
         switch (size) {  // drop through
-            case 3:
-                buf.append(key3 == this ? "(this Map)" : key3);
-                buf.append('=');
-                buf.append(value3 == this ? "(this Map)" : value3);
-                buf.append(',');
-            case 2:
-                buf.append(key2 == this ? "(this Map)" : key2);
-                buf.append('=');
-                buf.append(value2 == this ? "(this Map)" : value2);
-                buf.append(',');
-            case 1:
-                buf.append(key1 == this ? "(this Map)" : key1);
-                buf.append('=');
-                buf.append(value1 == this ? "(this Map)" : value1);
-                break;
-            // case 0: has already been dealt with
-            default:
-                throw new IllegalStateException("Invalid map index: " + size);
+        case 3:
+            buf.append(key3 == this ? "(this Map)" : key3);
+            buf.append('=');
+            buf.append(value3 == this ? "(this Map)" : value3);
+            buf.append(',');
+        case 2:
+            buf.append(key2 == this ? "(this Map)" : key2);
+            buf.append('=');
+            buf.append(value2 == this ? "(this Map)" : value2);
+            buf.append(',');
+        case 1:
+            buf.append(key1 == this ? "(this Map)" : key1);
+            buf.append('=');
+            buf.append(value1 == this ? "(this Map)" : value1);
+            break;
+        // case 0: has already been dealt with
+        default:
+            throw new IllegalStateException("Invalid map index: " + size);
         }
         buf.append('}');
         return buf.toString();
diff --git a/src/main/java/org/apache/commons/collections4/map/LRUMap.java b/src/main/java/org/apache/commons/collections4/map/LRUMap.java
index a49b0dc..a9fb500 100644
--- a/src/main/java/org/apache/commons/collections4/map/LRUMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/LRUMap.java
@@ -345,7 +345,7 @@ public class LRUMap<K, V>
                         "reuse=null, header.after=" + header.after + " header.before=" + header.before +
                         " key=" + key + " value=" + value + " size=" + size + " maxSize=" + maxSize +
                         " This should not occur if your keys are immutable and you used synchronization properly.");
-            }
+                }
                 reuseMapping(reuse, hashIndex, hashCode, key, value);
             } else {
                 super.addMapping(hashIndex, hashCode, key, value);
diff --git a/src/main/java/org/apache/commons/collections4/map/SingletonMap.java b/src/main/java/org/apache/commons/collections4/map/SingletonMap.java
index 3587bc3..e2a8665 100644
--- a/src/main/java/org/apache/commons/collections4/map/SingletonMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/SingletonMap.java
@@ -279,16 +279,16 @@ public class SingletonMap<K, V>
     @Override
     public void putAll(final Map<? extends K, ? extends V> map) {
         switch (map.size()) {
-            case 0:
-                return;
+        case 0:
+            return;
 
-            case 1:
-                final Map.Entry<? extends K, ? extends V> entry = map.entrySet().iterator().next();
-                put(entry.getKey(), entry.getValue());
-                return;
+        case 1:
+            final Map.Entry<? extends K, ? extends V> entry = map.entrySet().iterator().next();
+            put(entry.getKey(), entry.getValue());
+            return;
 
-            default:
-                throw new IllegalArgumentException("The map size must be 0 or 1");
+        default:
+            throw new IllegalArgumentException("The map size must be 0 or 1");
         }
     }
 
diff --git a/src/main/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMap.java b/src/main/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMap.java
index b05d901..11b633e 100644
--- a/src/main/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMap.java
+++ b/src/main/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMap.java
@@ -766,12 +766,12 @@ public abstract class AbstractMultiValuedMap<K, V> implements MultiValuedMap<K,
         final transient Map<K, Collection<V>> decoratedMap;
 
         AsMap(final Map<K, Collection<V>> map) {
-          this.decoratedMap = map;
+            this.decoratedMap = map;
         }
 
         @Override
         public Set<Map.Entry<K, Collection<V>>> entrySet() {
-          return new AsMapEntrySet();
+            return new AsMapEntrySet();
         }
 
         @Override
@@ -781,52 +781,51 @@ public abstract class AbstractMultiValuedMap<K, V> implements MultiValuedMap<K,
 
         @Override
         public Collection<V> get(final Object key) {
-          final Collection<V> collection = decoratedMap.get(key);
-          if (collection == null) {
-            return null;
-          }
-          @SuppressWarnings("unchecked")
-        final
-          K k = (K) key;
-          return wrappedCollection(k);
+            final Collection<V> collection = decoratedMap.get(key);
+            if (collection == null) {
+                return null;
+            }
+            @SuppressWarnings("unchecked")
+            final K k = (K) key;
+            return wrappedCollection(k);
         }
 
         @Override
         public Set<K> keySet() {
-          return AbstractMultiValuedMap.this.keySet();
+            return AbstractMultiValuedMap.this.keySet();
         }
 
         @Override
         public int size() {
-          return decoratedMap.size();
+            return decoratedMap.size();
         }
 
         @Override
         public Collection<V> remove(final Object key) {
-          final Collection<V> collection = decoratedMap.remove(key);
-          if (collection == null) {
-            return null;
-          }
+            final Collection<V> collection = decoratedMap.remove(key);
+            if (collection == null) {
+                return null;
+            }
 
-          final Collection<V> output = createCollection();
-          output.addAll(collection);
-          collection.clear();
-          return output;
+            final Collection<V> output = createCollection();
+            output.addAll(collection);
+            collection.clear();
+            return output;
         }
 
         @Override
         public boolean equals(final Object object) {
-          return this == object || decoratedMap.equals(object);
+            return this == object || decoratedMap.equals(object);
         }
 
         @Override
         public int hashCode() {
-          return decoratedMap.hashCode();
+            return decoratedMap.hashCode();
         }
 
         @Override
         public String toString() {
-          return decoratedMap.toString();
+            return decoratedMap.toString();
         }
 
         @Override
@@ -843,7 +842,7 @@ public abstract class AbstractMultiValuedMap<K, V> implements MultiValuedMap<K,
 
             @Override
             public int size() {
-              return AsMap.this.size();
+                return AsMap.this.size();
             }
 
             @Override
@@ -919,8 +918,7 @@ public abstract class AbstractMultiValuedMap<K, V> implements MultiValuedMap<K,
             final int valueSize = in.readInt();
             for (int j = 0; j < valueSize; j++) {
                 @SuppressWarnings("unchecked") // see above
-                final
-                V value = (V) in.readObject();
+                final V value = (V) in.readObject();
                 values.add(value);
             }
         }
diff --git a/src/main/java/org/apache/commons/collections4/multiset/AbstractMultiSet.java b/src/main/java/org/apache/commons/collections4/multiset/AbstractMultiSet.java
index a0a6813..0dbac08 100644
--- a/src/main/java/org/apache/commons/collections4/multiset/AbstractMultiSet.java
+++ b/src/main/java/org/apache/commons/collections4/multiset/AbstractMultiSet.java
@@ -408,29 +408,28 @@ public abstract class AbstractMultiSet<E> extends AbstractCollection<E> implemen
 
         @Override
         public boolean equals(final Object object) {
-          if (object instanceof Entry) {
-            final Entry<?> other = (Entry<?>) object;
-            final E element = this.getElement();
-            final Object otherElement = other.getElement();
-
-            return this.getCount() == other.getCount() &&
-                   (element == otherElement ||
-                    element != null && element.equals(otherElement));
-          }
-          return false;
+            if (object instanceof Entry) {
+                final Entry<?> other = (Entry<?>) object;
+                final E element = this.getElement();
+                final Object otherElement = other.getElement();
+
+                return this.getCount() == other.getCount() &&
+                       (element == otherElement ||
+                        element != null && element.equals(otherElement));
+            }
+            return false;
         }
 
         @Override
         public int hashCode() {
-          final E element = getElement();
-          return ((element == null) ? 0 : element.hashCode()) ^ getCount();
+            final E element = getElement();
+            return ((element == null) ? 0 : element.hashCode()) ^ getCount();
         }
 
         @Override
         public String toString() {
             return String.format("%s:%d", getElement(), getCount());
         }
-
     }
 
     //-----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/collections4/overview.html b/src/main/java/org/apache/commons/collections4/overview.html
index af3f718..2e81d3c 100644
--- a/src/main/java/org/apache/commons/collections4/overview.html
+++ b/src/main/java/org/apache/commons/collections4/overview.html
@@ -1,18 +1,18 @@
 <!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
 
-     http://www.apache.org/licenses/LICENSE-2.0
+       http://www.apache.org/licenses/LICENSE-2.0
 
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
 -->
 <body>
   <p>
diff --git a/src/main/java/org/apache/commons/collections4/set/CompositeSet.java b/src/main/java/org/apache/commons/collections4/set/CompositeSet.java
index 93975ed..72b8231 100644
--- a/src/main/java/org/apache/commons/collections4/set/CompositeSet.java
+++ b/src/main/java/org/apache/commons/collections4/set/CompositeSet.java
@@ -222,8 +222,8 @@ public class CompositeSet<E> implements Set<E>, Serializable {
     @Override
     public boolean add(final E obj) {
         if (mutator == null) {
-           throw new UnsupportedOperationException(
-               "add() is not supported on CompositeSet without a SetMutator strategy");
+            throw new UnsupportedOperationException(
+                "add() is not supported on CompositeSet without a SetMutator strategy");
         }
         return mutator.add(this, all, obj);
     }
diff --git a/src/main/java/org/apache/commons/collections4/trie/AbstractPatriciaTrie.java b/src/main/java/org/apache/commons/collections4/trie/AbstractPatriciaTrie.java
index f06ea3d..840d540 100644
--- a/src/main/java/org/apache/commons/collections4/trie/AbstractPatriciaTrie.java
+++ b/src/main/java/org/apache/commons/collections4/trie/AbstractPatriciaTrie.java
@@ -1834,122 +1834,122 @@ abstract class AbstractPatriciaTrie<K, V> extends AbstractBitwiseTrie<K, V> {
                                                           K toKey, boolean toInclusive);
     }
 
-   /**
-    * A {@link RangeMap} that deals with {@link Entry}s.
-    */
-   private class RangeEntryMap extends RangeMap {
-
-       /** The key to start from, null if the beginning. */
-       private final K fromKey;
-
-       /** The key to end at, null if till the end. */
-       private final K toKey;
-
-       /** Whether or not the 'from' is inclusive. */
-       private final boolean fromInclusive;
-
-       /** Whether or not the 'to' is inclusive. */
-       private final boolean toInclusive;
-
-       /**
-        * Creates a {@link RangeEntryMap} with the fromKey included and
-        * the toKey excluded from the range.
-        */
-       protected RangeEntryMap(final K fromKey, final K toKey) {
-           this(fromKey, true, toKey, false);
-       }
-
-       /**
-        * Creates a {@link RangeEntryMap}.
-        */
-       protected RangeEntryMap(final K fromKey, final boolean fromInclusive,
-                               final K toKey, final boolean toInclusive) {
-
-           if (fromKey == null && toKey == null) {
-               throw new IllegalArgumentException("must have a from or to!");
-           }
-
-           if (fromKey != null && toKey != null && getKeyAnalyzer().compare(fromKey, toKey) > 0) {
-               throw new IllegalArgumentException("fromKey > toKey");
-           }
-
-           this.fromKey = fromKey;
-           this.fromInclusive = fromInclusive;
-           this.toKey = toKey;
-           this.toInclusive = toInclusive;
-       }
-
-       @Override
-    public K firstKey() {
-           Map.Entry<K, V> e = null;
-           if (fromKey == null) {
-               e = firstEntry();
-           } else {
-               if (fromInclusive) {
-                   e = ceilingEntry(fromKey);
-               } else {
-                   e = higherEntry(fromKey);
-               }
-           }
-
-           final K first = e != null ? e.getKey() : null;
-           if (e == null || toKey != null && !inToRange(first, false)) {
-               throw new NoSuchElementException();
-           }
-           return first;
-       }
-
-       @Override
-    public K lastKey() {
-           Map.Entry<K, V> e;
-           if (toKey == null) {
-               e = lastEntry();
-           } else {
-               if (toInclusive) {
-                   e = floorEntry(toKey);
-               } else {
-                   e = lowerEntry(toKey);
-               }
-           }
-
-           final K last = e != null ? e.getKey() : null;
-           if (e == null || fromKey != null && !inFromRange(last, false)) {
-               throw new NoSuchElementException();
-           }
-           return last;
-       }
-
-       @Override
-       protected Set<Entry<K, V>> createEntrySet() {
-           return new RangeEntrySet(this);
-       }
-
-       @Override
-       public K getFromKey() {
-           return fromKey;
-       }
-
-       @Override
-       public K getToKey() {
-           return toKey;
-       }
-
-       @Override
-       public boolean isFromInclusive() {
-           return fromInclusive;
-       }
-
-       @Override
-       public boolean isToInclusive() {
-           return toInclusive;
-       }
-
-       @Override
-       protected SortedMap<K, V> createRangeMap(final K fromKey, final boolean fromInclusive,
-                                                final K toKey, final boolean toInclusive) {
-           return new RangeEntryMap(fromKey, fromInclusive, toKey, toInclusive);
-       }
-   }
+    /**
+     * A {@link RangeMap} that deals with {@link Entry}s.
+     */
+    private class RangeEntryMap extends RangeMap {
+
+        /** The key to start from, null if the beginning. */
+        private final K fromKey;
+
+        /** The key to end at, null if till the end. */
+        private final K toKey;
+
+        /** Whether or not the 'from' is inclusive. */
+        private final boolean fromInclusive;
+
+        /** Whether or not the 'to' is inclusive. */
+        private final boolean toInclusive;
+
+        /**
+         * Creates a {@link RangeEntryMap} with the fromKey included and
+         * the toKey excluded from the range.
+         */
+        protected RangeEntryMap(final K fromKey, final K toKey) {
+            this(fromKey, true, toKey, false);
+        }
+
+        /**
+         * Creates a {@link RangeEntryMap}.
+         */
+        protected RangeEntryMap(final K fromKey, final boolean fromInclusive,
+                                final K toKey, final boolean toInclusive) {
+
+            if (fromKey == null && toKey == null) {
+                throw new IllegalArgumentException("must have a from or to!");
+            }
+
+            if (fromKey != null && toKey != null && getKeyAnalyzer().compare(fromKey, toKey) > 0) {
+                throw new IllegalArgumentException("fromKey > toKey");
+            }
+
+            this.fromKey = fromKey;
+            this.fromInclusive = fromInclusive;
+            this.toKey = toKey;
+            this.toInclusive = toInclusive;
+        }
+
+        @Override
+        public K firstKey() {
+            Map.Entry<K, V> e = null;
+            if (fromKey == null) {
+                e = firstEntry();
+            } else {
+                if (fromInclusive) {
+                    e = ceilingEntry(fromKey);
+                } else {
+                    e = higherEntry(fromKey);
+                }
+            }
+
+            final K first = e != null ? e.getKey() : null;
+            if (e == null || toKey != null && !inToRange(first, false)) {
+                throw new NoSuchElementException();
+            }
+            return first;
+        }
+
+        @Override
+        public K lastKey() {
+            Map.Entry<K, V> e;
+            if (toKey == null) {
+                e = lastEntry();
+            } else {
+                if (toInclusive) {
+                    e = floorEntry(toKey);
+                } else {
+                    e = lowerEntry(toKey);
+                }
+            }
+
+            final K last = e != null ? e.getKey() : null;
+            if (e == null || fromKey != null && !inFromRange(last, false)) {
+                throw new NoSuchElementException();
+            }
+            return last;
+        }
+
+        @Override
+        protected Set<Entry<K, V>> createEntrySet() {
+            return new RangeEntrySet(this);
+        }
+
+        @Override
+        public K getFromKey() {
+            return fromKey;
+        }
+
+        @Override
+        public K getToKey() {
+            return toKey;
+        }
+
+        @Override
+        public boolean isFromInclusive() {
+            return fromInclusive;
+        }
+
+        @Override
+        public boolean isToInclusive() {
+            return toInclusive;
+        }
+
+        @Override
+        protected SortedMap<K, V> createRangeMap(final K fromKey, final boolean fromInclusive,
+                                                 final K toKey, final boolean toInclusive) {
+            return new RangeEntryMap(fromKey, fromInclusive, toKey, toInclusive);
+        }
+    }
 
     /**
      * A {@link Set} view of a {@link RangeMap}.
diff --git a/src/main/java/org/apache/commons/collections4/trie/analyzer/StringKeyAnalyzer.java b/src/main/java/org/apache/commons/collections4/trie/analyzer/StringKeyAnalyzer.java
index a6d25a5..a7ef3bc 100644
--- a/src/main/java/org/apache/commons/collections4/trie/analyzer/StringKeyAnalyzer.java
+++ b/src/main/java/org/apache/commons/collections4/trie/analyzer/StringKeyAnalyzer.java
@@ -91,8 +91,8 @@ public class StringKeyAnalyzer extends KeyAnalyzer<String> {
             }
 
             if (k != f) {
-               final int x = k ^ f;
-               return i * LENGTH + Integer.numberOfLeadingZeros(x) - LENGTH;
+                final int x = k ^ f;
+                return i * LENGTH + Integer.numberOfLeadingZeros(x) - LENGTH;
             }
 
             if (k != 0) {
diff --git a/src/test/java/org/apache/commons/collections4/BulkTest.java b/src/test/java/org/apache/commons/collections4/BulkTest.java
index c078ce3..0355464 100644
--- a/src/test/java/org/apache/commons/collections4/BulkTest.java
+++ b/src/test/java/org/apache/commons/collections4/BulkTest.java
@@ -294,21 +294,21 @@ class BulkTestSuiteMaker {
     /**
      * Makes a hierarchical TestSuite based on the starting class.
      *
-     * @return  the hierarchical TestSuite for startingClass
+     * @return the hierarchical TestSuite for startingClass
      */
     public TestSuite make() {
-         this.result = new TestSuite();
-         this.prefix = getBaseName(startingClass);
-         result.setName(prefix);
-
-         final BulkTest bulk = makeFirstTestCase(startingClass);
-         ignored = new ArrayList<>();
-         final String[] s = bulk.ignoredTests();
-         if (s != null) {
-             ignored.addAll(Arrays.asList(s));
-         }
-         make(bulk);
-         return result;
+        this.result = new TestSuite();
+        this.prefix = getBaseName(startingClass);
+        result.setName(prefix);
+
+        final BulkTest bulk = makeFirstTestCase(startingClass);
+        ignored = new ArrayList<>();
+        final String[] s = bulk.ignoredTests();
+        if (s != null) {
+            ignored.addAll(Arrays.asList(s));
+        }
+        make(bulk);
+        return result;
     }
 
     /**
diff --git a/src/test/java/org/apache/commons/collections4/ClosureUtilsTest.java b/src/test/java/org/apache/commons/collections4/ClosureUtilsTest.java
index 0bfaa43..226713b 100644
--- a/src/test/java/org/apache/commons/collections4/ClosureUtilsTest.java
+++ b/src/test/java/org/apache/commons/collections4/ClosureUtilsTest.java
@@ -411,8 +411,8 @@ public class ClosureUtilsTest {
     @Test
     public void testSingletonPatternInSerialization() {
         final Object[] singletones = new Object[] {
-                ExceptionClosure.INSTANCE,
-                NOPClosure.INSTANCE,
+            ExceptionClosure.INSTANCE,
+            NOPClosure.INSTANCE,
         };
 
         for (final Object original : singletones) {
diff --git a/src/test/java/org/apache/commons/collections4/EnumerationUtilsTest.java b/src/test/java/org/apache/commons/collections4/EnumerationUtilsTest.java
index 9445493..0c37ca5 100644
--- a/src/test/java/org/apache/commons/collections4/EnumerationUtilsTest.java
+++ b/src/test/java/org/apache/commons/collections4/EnumerationUtilsTest.java
@@ -119,9 +119,9 @@ public class EnumerationUtilsTest {
     public void testToListWithStringTokenizer() {
         final List<String> expectedList1 = new ArrayList<>();
         final StringTokenizer st = new StringTokenizer(TO_LIST_FIXTURE);
-             while (st.hasMoreTokens()) {
-                 expectedList1.add(st.nextToken());
-             }
+        while (st.hasMoreTokens()) {
+            expectedList1.add(st.nextToken());
+        }
         final List<String> expectedList2 = new ArrayList<>();
         expectedList2.add("this");
         expectedList2.add("is");
diff --git a/src/test/java/org/apache/commons/collections4/FactoryUtilsTest.java b/src/test/java/org/apache/commons/collections4/FactoryUtilsTest.java
index 5dcfcea..437dcd6 100644
--- a/src/test/java/org/apache/commons/collections4/FactoryUtilsTest.java
+++ b/src/test/java/org/apache/commons/collections4/FactoryUtilsTest.java
@@ -261,7 +261,7 @@ public class FactoryUtilsTest {
     @Test
     public void testSingletonPatternInSerialization() {
         final Object[] singletones = new Object[] {
-                ExceptionFactory.INSTANCE,
+            ExceptionFactory.INSTANCE,
         };
 
         for (final Object original : singletones) {
diff --git a/src/test/java/org/apache/commons/collections4/ListUtilsTest.java b/src/test/java/org/apache/commons/collections4/ListUtilsTest.java
index f2069e8..8d26760 100644
--- a/src/test/java/org/apache/commons/collections4/ListUtilsTest.java
+++ b/src/test/java/org/apache/commons/collections4/ListUtilsTest.java
@@ -377,39 +377,39 @@ public class ListUtilsTest {
     @Test
     public void testLongestCommonSubsequenceWithString() {
 
-      try {
-          ListUtils.longestCommonSubsequence((String) null, null);
-          fail("failed to check for null argument");
-      } catch (final NullPointerException e) {}
+        try {
+            ListUtils.longestCommonSubsequence((String) null, null);
+            fail("failed to check for null argument");
+        } catch (final NullPointerException e) {}
 
-      try {
-          ListUtils.longestCommonSubsequence("A", null);
-          fail("failed to check for null argument");
-      } catch (final NullPointerException e) {}
+        try {
+            ListUtils.longestCommonSubsequence("A", null);
+            fail("failed to check for null argument");
+        } catch (final NullPointerException e) {}
 
-      try {
-          ListUtils.longestCommonSubsequence(null, "A");
-          fail("failed to check for null argument");
-      } catch (final NullPointerException e) {}
+        try {
+            ListUtils.longestCommonSubsequence(null, "A");
+            fail("failed to check for null argument");
+        } catch (final NullPointerException e) {}
 
-      String lcs = ListUtils.longestCommonSubsequence("", "");
-      assertEquals(0, lcs.length());
+        String lcs = ListUtils.longestCommonSubsequence("", "");
+        assertEquals(0, lcs.length());
 
-      final String banana = "BANANA";
-      final String ananas = "ANANAS";
-      lcs = ListUtils.longestCommonSubsequence(banana, ananas);
+        final String banana = "BANANA";
+        final String ananas = "ANANAS";
+        lcs = ListUtils.longestCommonSubsequence(banana, ananas);
 
-      assertEquals("ANANA", lcs);
+        assertEquals("ANANA", lcs);
 
-      final String atana = "ATANA";
-      lcs = ListUtils.longestCommonSubsequence(banana, atana);
+        final String atana = "ATANA";
+        lcs = ListUtils.longestCommonSubsequence(banana, atana);
 
-      assertEquals("AANA", lcs);
+        assertEquals("AANA", lcs);
 
-      final String zorro = "ZORRO";
-      lcs = ListUtils.longestCommonSubsequence(banana, zorro);
+        final String zorro = "ZORRO";
+        lcs = ListUtils.longestCommonSubsequence(banana, zorro);
 
-      assertEquals(0, lcs.length());
+        assertEquals(0, lcs.length());
     }
 
     @Test
diff --git a/src/test/java/org/apache/commons/collections4/MapUtilsTest.java b/src/test/java/org/apache/commons/collections4/MapUtilsTest.java
index 7ee9897..bf8443a 100644
--- a/src/test/java/org/apache/commons/collections4/MapUtilsTest.java
+++ b/src/test/java/org/apache/commons/collections4/MapUtilsTest.java
@@ -188,36 +188,36 @@ public class MapUtilsTest extends AbstractAvailableLocalesTest {
 
         try {
             MapUtils.putAll(new HashMap<String, String>(), new String[][] {
-                    {"RED", "#FF0000"},
-                    null,
-                    {"BLUE", "#0000FF"}
+                {"RED", "#FF0000"},
+                null,
+                {"BLUE", "#0000FF"}
             });
             fail();
         } catch (final IllegalArgumentException ex) {}
 
         try {
             MapUtils.putAll(new HashMap<String, String>(), new String[][] {
-                    {"RED", "#FF0000"},
-                    {"GREEN"},
-                    {"BLUE", "#0000FF"}
+                {"RED", "#FF0000"},
+                {"GREEN"},
+                {"BLUE", "#0000FF"}
             });
             fail();
         } catch (final IllegalArgumentException ex) {}
 
         try {
             MapUtils.putAll(new HashMap<String, String>(), new String[][] {
-                    {"RED", "#FF0000"},
-                    {},
-                    {"BLUE", "#0000FF"}
+                {"RED", "#FF0000"},
+                {},
+                {"BLUE", "#0000FF"}
             });
             fail();
         } catch (final IllegalArgumentException ex) {}
 
         // flat array
         test = MapUtils.putAll(new HashMap<String, String>(), new String[] {
-                "RED", "#FF0000",
-                "GREEN", "#00FF00",
-                "BLUE", "#0000FF"
+            "RED", "#FF0000",
+            "GREEN", "#00FF00",
+            "BLUE", "#0000FF"
         });
         assertEquals(true, test.containsKey("RED"));
         assertEquals("#FF0000", test.get("RED"));
@@ -228,10 +228,10 @@ public class MapUtilsTest extends AbstractAvailableLocalesTest {
         assertEquals(3, test.size());
 
         test = MapUtils.putAll(new HashMap<String, String>(), new String[] {
-                "RED", "#FF0000",
-                "GREEN", "#00FF00",
-                "BLUE", "#0000FF",
-                "PURPLE" // ignored
+            "RED", "#FF0000",
+            "GREEN", "#00FF00",
+            "BLUE", "#0000FF",
+            "PURPLE" // ignored
         });
         assertEquals(true, test.containsKey("RED"));
         assertEquals("#FF0000", test.get("RED"));
@@ -246,9 +246,9 @@ public class MapUtilsTest extends AbstractAvailableLocalesTest {
 
         // map entry
         test = MapUtils.putAll(new HashMap<String, String>(), new Object[] {
-                new DefaultMapEntry<>("RED", "#FF0000"),
-                new DefaultMapEntry<>("GREEN", "#00FF00"),
-                new DefaultMapEntry<>("BLUE", "#0000FF")
+            new DefaultMapEntry<>("RED", "#FF0000"),
+            new DefaultMapEntry<>("GREEN", "#00FF00"),
+            new DefaultMapEntry<>("BLUE", "#0000FF")
         });
         assertEquals(true, test.containsKey("RED"));
         assertEquals("#FF0000", test.get("RED"));
@@ -260,9 +260,9 @@ public class MapUtilsTest extends AbstractAvailableLocalesTest {
 
         // key value
         test = MapUtils.putAll(new HashMap<String, String>(), new Object[] {
-                new DefaultKeyValue<>("RED", "#FF0000"),
-                new DefaultKeyValue<>("GREEN", "#00FF00"),
-                new DefaultKeyValue<>("BLUE", "#0000FF")
+            new DefaultKeyValue<>("RED", "#FF0000"),
+            new DefaultKeyValue<>("GREEN", "#00FF00"),
+            new DefaultKeyValue<>("BLUE", "#0000FF")
         });
         assertEquals(true, test.containsKey("RED"));
         assertEquals("#FF0000", test.get("RED"));
diff --git a/src/test/java/org/apache/commons/collections4/PredicateUtilsTest.java b/src/test/java/org/apache/commons/collections4/PredicateUtilsTest.java
index 4110e92..3613a8c 100644
--- a/src/test/java/org/apache/commons/collections4/PredicateUtilsTest.java
+++ b/src/test/java/org/apache/commons/collections4/PredicateUtilsTest.java
@@ -699,11 +699,11 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
     @Test
     public void testSingletonPatternInSerialization() {
         final Object[] singletones = new Object[] {
-                ExceptionPredicate.INSTANCE,
-                FalsePredicate.INSTANCE,
-                NotNullPredicate.INSTANCE,
-                NullPredicate.INSTANCE,
-                TruePredicate.INSTANCE
+            ExceptionPredicate.INSTANCE,
+            FalsePredicate.INSTANCE,
+            NotNullPredicate.INSTANCE,
+            NullPredicate.INSTANCE,
+            TruePredicate.INSTANCE
         };
 
         for (final Object original : singletones) {
@@ -718,5 +718,4 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
     protected Predicate<?> generatePredicate() {
         return truePredicate();  //Just return something to satisfy super class.
     }
-
 }
diff --git a/src/test/java/org/apache/commons/collections4/TransformerUtilsTest.java b/src/test/java/org/apache/commons/collections4/TransformerUtilsTest.java
index 50361a2..b9f9679 100644
--- a/src/test/java/org/apache/commons/collections4/TransformerUtilsTest.java
+++ b/src/test/java/org/apache/commons/collections4/TransformerUtilsTest.java
@@ -434,7 +434,7 @@ public class TransformerUtilsTest {
     @Test
     public void testStringValueTransformer() {
         assertNotNull( "StringValueTransformer should NEVER return a null value.",
-           TransformerUtils.stringValueTransformer().transform(null));
+            TransformerUtils.stringValueTransformer().transform(null));
         assertEquals( "StringValueTransformer should return \"null\" when given a null argument.", "null",
             TransformerUtils.stringValueTransformer().transform(null));
         assertEquals( "StringValueTransformer should return toString value", "6",
@@ -478,14 +478,13 @@ public class TransformerUtilsTest {
     @Test
     public void testSingletonPatternInSerialization() {
         final Object[] singletones = new Object[] {
-                ExceptionTransformer.INSTANCE,
-                NOPTransformer.INSTANCE,
-                StringValueTransformer.stringValueTransformer(),
+            ExceptionTransformer.INSTANCE,
+            NOPTransformer.INSTANCE,
+            StringValueTransformer.stringValueTransformer(),
         };
 
         for (final Object original : singletones) {
             TestUtils.assertSameAfterSerialization("Singleton pattern broken for " + original.getClass(), original);
         }
     }
-
 }
diff --git a/src/test/java/org/apache/commons/collections4/bag/AbstractSortedBagTest.java b/src/test/java/org/apache/commons/collections4/bag/AbstractSortedBagTest.java
index 8be7b63..0462b4f 100644
--- a/src/test/java/org/apache/commons/collections4/bag/AbstractSortedBagTest.java
+++ b/src/test/java/org/apache/commons/collections4/bag/AbstractSortedBagTest.java
@@ -53,7 +53,7 @@ public abstract class AbstractSortedBagTest<T> extends AbstractBagTest<T> {
                 first = colliter.next();
                 last = first;
             } else {
-              last = colliter.next();
+                last = colliter.next();
             }
             assertEquals("Element appears to be out of order.", last, confiter.next());
         }
diff --git a/src/test/java/org/apache/commons/collections4/bag/PredicatedBagTest.java b/src/test/java/org/apache/commons/collections4/bag/PredicatedBagTest.java
index f4c17be..4a1f3a9 100644
--- a/src/test/java/org/apache/commons/collections4/bag/PredicatedBagTest.java
+++ b/src/test/java/org/apache/commons/collections4/bag/PredicatedBagTest.java
@@ -93,7 +93,7 @@ public class PredicatedBagTest<T> extends AbstractBagTest<T> {
             // expected
         }
         assertTrue("Collection shouldn't contain illegal element",
-         !bag.contains(i));
+            !bag.contains(i));
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/test/java/org/apache/commons/collections4/collection/AbstractCollectionTest.java b/src/test/java/org/apache/commons/collections4/collection/AbstractCollectionTest.java
index f26438f..c402c43 100644
--- a/src/test/java/org/apache/commons/collections4/collection/AbstractCollectionTest.java
+++ b/src/test/java/org/apache/commons/collections4/collection/AbstractCollectionTest.java
@@ -474,7 +474,7 @@ public abstract class AbstractCollectionTest<E> extends AbstractObjectTest {
     public Object[] getFullNonNullStringElements() {
         return new Object[] {
             "If", "the", "dull", "substance", "of", "my", "flesh", "were",
-                "thought", "Injurious", "distance", "could", "not", "stop", "my", "way",
+            "thought", "Injurious", "distance", "could", "not", "stop", "my", "way",
         };
     }
 
@@ -487,7 +487,7 @@ public abstract class AbstractCollectionTest<E> extends AbstractObjectTest {
     public Object[] getOtherNonNullStringElements() {
         return new Object[] {
             "For", "then", "despite", /* of */"space", "I", "would", "be",
-                "brought", "From", "limits", "far", "remote", "where", "thou", "dost", "stay"
+            "brought", "From", "limits", "far", "remote", "where", "thou", "dost", "stay"
         };
     }
 
diff --git a/src/test/java/org/apache/commons/collections4/collection/CompositeCollectionTest.java b/src/test/java/org/apache/commons/collections4/collection/CompositeCollectionTest.java
index 12093ff..b1f2984 100644
--- a/src/test/java/org/apache/commons/collections4/collection/CompositeCollectionTest.java
+++ b/src/test/java/org/apache/commons/collections4/collection/CompositeCollectionTest.java
@@ -36,7 +36,7 @@ public class CompositeCollectionTest<E> extends AbstractCollectionTest<E> {
 
     protected CompositeCollection<E> c;
 
- protected Collection<E> one;
+    protected Collection<E> one;
 
     protected Collection<E> two;
 
diff --git a/src/test/java/org/apache/commons/collections4/collection/PredicatedCollectionTest.java b/src/test/java/org/apache/commons/collections4/collection/PredicatedCollectionTest.java
index 65dd4bc..6fe953b 100644
--- a/src/test/java/org/apache/commons/collections4/collection/PredicatedCollectionTest.java
+++ b/src/test/java/org/apache/commons/collections4/collection/PredicatedCollectionTest.java
@@ -93,7 +93,7 @@ public class PredicatedCollectionTest<E> extends AbstractCollectionTest<E> {
             // expected
         }
         assertTrue("Collection shouldn't contain illegal element",
-         !c.contains(i));
+            !c.contains(i));
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/test/java/org/apache/commons/collections4/comparators/TransformingComparatorTest.java b/src/test/java/org/apache/commons/collections4/comparators/TransformingComparatorTest.java
index 81d8481..e9df288 100644
--- a/src/test/java/org/apache/commons/collections4/comparators/TransformingComparatorTest.java
+++ b/src/test/java/org/apache/commons/collections4/comparators/TransformingComparatorTest.java
@@ -44,8 +44,8 @@ public class TransformingComparatorTest extends AbstractComparatorTest<Integer>
 
     @Override
     public Comparator<Integer> makeObject() {
-       final Comparator<String> decorated = new ComparableComparator<>();
-       return ComparatorUtils.transformedComparator(decorated, TransformerUtils.<Integer>stringValueTransformer());
+        final Comparator<String> decorated = new ComparableComparator<>();
+        return ComparatorUtils.transformedComparator(decorated, TransformerUtils.<Integer>stringValueTransformer());
     }
 
     @Override
diff --git a/src/test/java/org/apache/commons/collections4/functors/EqualPredicateTest.java b/src/test/java/org/apache/commons/collections4/functors/EqualPredicateTest.java
index ac027fc..4cc4c91 100644
--- a/src/test/java/org/apache/commons/collections4/functors/EqualPredicateTest.java
+++ b/src/test/java/org/apache/commons/collections4/functors/EqualPredicateTest.java
@@ -30,7 +30,7 @@ public class EqualPredicateTest extends AbstractPredicateTest {
 
     @Override
     protected Predicate<Object> generatePredicate() {
-       return equalPredicate(null);
+        return equalPredicate(null);
     }
 
     @Test
diff --git a/src/test/java/org/apache/commons/collections4/iterators/CollatingIteratorTest.java b/src/test/java/org/apache/commons/collections4/iterators/CollatingIteratorTest.java
index 06d7a5a..1f5106a 100644
--- a/src/test/java/org/apache/commons/collections4/iterators/CollatingIteratorTest.java
+++ b/src/test/java/org/apache/commons/collections4/iterators/CollatingIteratorTest.java
@@ -146,61 +146,61 @@ public class CollatingIteratorTest extends AbstractIteratorTest<Integer> {
         iter.addIterator(evens.iterator());
         iter.addIterator(odds.iterator());
 
-        assertEquals(Integer.valueOf(0), iter.next()); // even 0
+        assertEquals(Integer.valueOf(0), iter.next());  // even   0
         assertEquals(1, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(1), iter.next()); // fib 1
+        assertEquals(Integer.valueOf(1), iter.next());  // fib    1
         assertEquals(0, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(1), iter.next()); // fib 1
+        assertEquals(Integer.valueOf(1), iter.next());  // fib    1
         assertEquals(0, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(1), iter.next()); // odd 1
+        assertEquals(Integer.valueOf(1), iter.next());  // odd    1
         assertEquals(2, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(2), iter.next()); // fib 2
+        assertEquals(Integer.valueOf(2), iter.next());  // fib    2
         assertEquals(0, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(2), iter.next()); // even 2
+        assertEquals(Integer.valueOf(2), iter.next());  // even   2
         assertEquals(1, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(3), iter.next()); // fib 3
+        assertEquals(Integer.valueOf(3), iter.next());  // fib    3
         assertEquals(0, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(3), iter.next()); // odd 3
+        assertEquals(Integer.valueOf(3), iter.next());  // odd    3
         assertEquals(2, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(4), iter.next()); // even 4
+        assertEquals(Integer.valueOf(4), iter.next());  // even   4
         assertEquals(1, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(5), iter.next()); // fib 5
+        assertEquals(Integer.valueOf(5), iter.next());  // fib    5
         assertEquals(0, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(5), iter.next()); // odd 5
+        assertEquals(Integer.valueOf(5), iter.next());  // odd    5
         assertEquals(2, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(6), iter.next()); // even 6
+        assertEquals(Integer.valueOf(6), iter.next());  // even   6
         assertEquals(1, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(7), iter.next()); // odd 7
+        assertEquals(Integer.valueOf(7), iter.next());  // odd    7
         assertEquals(2, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(8), iter.next()); // fib 8
+        assertEquals(Integer.valueOf(8), iter.next());  // fib    8
         assertEquals(0, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(8), iter.next()); // even 8
+        assertEquals(Integer.valueOf(8), iter.next());  // even   8
         assertEquals(1, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(9), iter.next()); // odd 9
+        assertEquals(Integer.valueOf(9), iter.next());  // odd    9
         assertEquals(2, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(10), iter.next()); // even 10
+        assertEquals(Integer.valueOf(10), iter.next()); // even  10
         assertEquals(1, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(11), iter.next()); // odd 11
+        assertEquals(Integer.valueOf(11), iter.next()); // odd   11
         assertEquals(2, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(12), iter.next()); // even 12
+        assertEquals(Integer.valueOf(12), iter.next()); // even  12
         assertEquals(1, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(13), iter.next()); // fib 13
+        assertEquals(Integer.valueOf(13), iter.next()); // fib   13
         assertEquals(0, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(13), iter.next()); // odd 13
+        assertEquals(Integer.valueOf(13), iter.next()); // odd   13
         assertEquals(2, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(14), iter.next()); // even 14
+        assertEquals(Integer.valueOf(14), iter.next()); // even  14
         assertEquals(1, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(15), iter.next()); // odd 15
+        assertEquals(Integer.valueOf(15), iter.next()); // odd   15
         assertEquals(2, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(16), iter.next()); // even 16
+        assertEquals(Integer.valueOf(16), iter.next()); // even  16
         assertEquals(1, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(17), iter.next()); // odd 17
+        assertEquals(Integer.valueOf(17), iter.next()); // odd   17
         assertEquals(2, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(18), iter.next()); // even 18
+        assertEquals(Integer.valueOf(18), iter.next()); // even  18
         assertEquals(1, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(19), iter.next()); // odd 19
+        assertEquals(Integer.valueOf(19), iter.next()); // odd   19
         assertEquals(2, iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(21), iter.next()); // fib 21
+        assertEquals(Integer.valueOf(21), iter.next()); // fib   21
         assertEquals(0, iter.getIteratorIndex());
 
         assertTrue(!iter.hasNext());
@@ -238,24 +238,24 @@ public class CollatingIteratorTest extends AbstractIteratorTest<Integer> {
     }
 
     public void testNullComparator() {
-       final List<Integer> l1 = Arrays.asList(1, 3, 5);
-       final List<Integer> l2 = Arrays.asList(2, 4, 6);
+        final List<Integer> l1 = Arrays.asList(1, 3, 5);
+        final List<Integer> l2 = Arrays.asList(2, 4, 6);
 
-       final CollatingIterator<Integer> collatingIterator1 = new CollatingIterator<>(null, l1.iterator(), l2.iterator());
-       try {
-           collatingIterator1.next();
-       } catch (final NullPointerException e) {
-           assertTrue(e.getMessage().startsWith("You must invoke setComparator"));
-       }
+        final CollatingIterator<Integer> collatingIterator1 = new CollatingIterator<>(null, l1.iterator(), l2.iterator());
+        try {
+            collatingIterator1.next();
+        } catch (final NullPointerException e) {
+            assertTrue(e.getMessage().startsWith("You must invoke setComparator"));
+        }
 
-       int i = 0;
-       final CollatingIterator<Integer> collatingIterator2 = new CollatingIterator<>(null, l1.iterator(), l2.iterator());
-       collatingIterator2.setComparator(new ComparableComparator<Integer>());
-       for ( ; collatingIterator2.hasNext(); i++ ) {
-          final Integer n = collatingIterator2.next();
-          assertEquals("wrong order", (int) n, i + 1);
-       }
-       assertEquals("wrong size", i, l1.size() + l2.size());
+        int i = 0;
+        final CollatingIterator<Integer> collatingIterator2 = new CollatingIterator<>(null, l1.iterator(), l2.iterator());
+        collatingIterator2.setComparator(new ComparableComparator<Integer>());
+        for ( ; collatingIterator2.hasNext(); i++ ) {
+            final Integer n = collatingIterator2.next();
+            assertEquals("wrong order", (int) n, i + 1);
+        }
+        assertEquals("wrong size", i, l1.size() + l2.size());
     }
 }
 
diff --git a/src/test/java/org/apache/commons/collections4/iterators/SingletonListIteratorTest.java b/src/test/java/org/apache/commons/collections4/iterators/SingletonListIteratorTest.java
index 3daddde..e96980f 100644
--- a/src/test/java/org/apache/commons/collections4/iterators/SingletonListIteratorTest.java
+++ b/src/test/java/org/apache/commons/collections4/iterators/SingletonListIteratorTest.java
@@ -101,15 +101,15 @@ public class SingletonListIteratorTest<E> extends AbstractListIteratorTest<E> {
         try {
             iter.next();
         } catch (final Exception e) {
-          assertTrue("NoSuchElementException must be thrown",
-             e.getClass().equals(new NoSuchElementException().getClass()));
+            assertTrue("NoSuchElementException must be thrown",
+                e.getClass().equals(new NoSuchElementException().getClass()));
         }
         iter.previous();
         try {
             iter.previous();
         } catch (final Exception e) {
-          assertTrue("NoSuchElementException must be thrown",
-             e.getClass().equals(new NoSuchElementException().getClass()));
+            assertTrue("NoSuchElementException must be thrown",
+                e.getClass().equals(new NoSuchElementException().getClass()));
         }
     }
 
diff --git a/src/test/java/org/apache/commons/collections4/iterators/ZippingIteratorTest.java b/src/test/java/org/apache/commons/collections4/iterators/ZippingIteratorTest.java
index 789ac13..cbb7e05 100644
--- a/src/test/java/org/apache/commons/collections4/iterators/ZippingIteratorTest.java
+++ b/src/test/java/org/apache/commons/collections4/iterators/ZippingIteratorTest.java
@@ -125,34 +125,34 @@ public class ZippingIteratorTest extends AbstractIteratorTest<Integer> {
     public void testIterateFibEvenOdd() {
         final ZippingIterator<Integer> iter = new ZippingIterator<>(fib.iterator(), evens.iterator(), odds.iterator());
 
-        assertEquals(Integer.valueOf(1), iter.next()); // fib 1
-        assertEquals(Integer.valueOf(0), iter.next()); // even 0
-        assertEquals(Integer.valueOf(1), iter.next()); // odd 1
-        assertEquals(Integer.valueOf(1), iter.next()); // fib 1
-        assertEquals(Integer.valueOf(2), iter.next()); // even 2
-        assertEquals(Integer.valueOf(3), iter.next()); // odd 3
-        assertEquals(Integer.valueOf(2), iter.next()); // fib 2
-        assertEquals(Integer.valueOf(4), iter.next()); // even 4
-        assertEquals(Integer.valueOf(5), iter.next()); // odd 5
-        assertEquals(Integer.valueOf(3), iter.next()); // fib 3
-        assertEquals(Integer.valueOf(6), iter.next()); // even 6
-        assertEquals(Integer.valueOf(7), iter.next()); // odd 7
-        assertEquals(Integer.valueOf(5), iter.next()); // fib 5
-        assertEquals(Integer.valueOf(8), iter.next()); // even 8
-        assertEquals(Integer.valueOf(9), iter.next()); // odd 9
-        assertEquals(Integer.valueOf(8), iter.next()); // fib 8
-        assertEquals(Integer.valueOf(10), iter.next()); // even 10
-        assertEquals(Integer.valueOf(11), iter.next()); // odd 11
-        assertEquals(Integer.valueOf(13), iter.next()); // fib 13
-        assertEquals(Integer.valueOf(12), iter.next()); // even 12
-        assertEquals(Integer.valueOf(13), iter.next()); // odd 13
-        assertEquals(Integer.valueOf(21), iter.next()); // fib 21
-        assertEquals(Integer.valueOf(14), iter.next()); // even 14
-        assertEquals(Integer.valueOf(15), iter.next()); // odd 15
-        assertEquals(Integer.valueOf(16), iter.next()); // even 16
-        assertEquals(Integer.valueOf(17), iter.next()); // odd 17
-        assertEquals(Integer.valueOf(18), iter.next()); // even 18
-        assertEquals(Integer.valueOf(19), iter.next()); // odd 19
+        assertEquals(Integer.valueOf(1), iter.next());  // fib    1
+        assertEquals(Integer.valueOf(0), iter.next());  // even   0
+        assertEquals(Integer.valueOf(1), iter.next());  // odd    1
+        assertEquals(Integer.valueOf(1), iter.next());  // fib    1
+        assertEquals(Integer.valueOf(2), iter.next());  // even   2
+        assertEquals(Integer.valueOf(3), iter.next());  // odd    3
+        assertEquals(Integer.valueOf(2), iter.next());  // fib    2
+        assertEquals(Integer.valueOf(4), iter.next());  // even   4
+        assertEquals(Integer.valueOf(5), iter.next());  // odd    5
+        assertEquals(Integer.valueOf(3), iter.next());  // fib    3
+        assertEquals(Integer.valueOf(6), iter.next());  // even   6
+        assertEquals(Integer.valueOf(7), iter.next());  // odd    7
+        assertEquals(Integer.valueOf(5), iter.next());  // fib    5
+        assertEquals(Integer.valueOf(8), iter.next());  // even   8
+        assertEquals(Integer.valueOf(9), iter.next());  // odd    9
+        assertEquals(Integer.valueOf(8), iter.next());  // fib    8
+        assertEquals(Integer.valueOf(10), iter.next()); // even  10
+        assertEquals(Integer.valueOf(11), iter.next()); // odd   11
+        assertEquals(Integer.valueOf(13), iter.next()); // fib   13
+        assertEquals(Integer.valueOf(12), iter.next()); // even  12
+        assertEquals(Integer.valueOf(13), iter.next()); // odd   13
+        assertEquals(Integer.valueOf(21), iter.next()); // fib   21
+        assertEquals(Integer.valueOf(14), iter.next()); // even  14
+        assertEquals(Integer.valueOf(15), iter.next()); // odd   15
+        assertEquals(Integer.valueOf(16), iter.next()); // even  16
+        assertEquals(Integer.valueOf(17), iter.next()); // odd   17
+        assertEquals(Integer.valueOf(18), iter.next()); // even  18
+        assertEquals(Integer.valueOf(19), iter.next()); // odd   19
 
         assertTrue(!iter.hasNext());
     }
diff --git a/src/test/java/org/apache/commons/collections4/list/AbstractLinkedListTest.java b/src/test/java/org/apache/commons/collections4/list/AbstractLinkedListTest.java
index 9037b1b..395ad8a 100644
--- a/src/test/java/org/apache/commons/collections4/list/AbstractLinkedListTest.java
+++ b/src/test/java/org/apache/commons/collections4/list/AbstractLinkedListTest.java
@@ -163,7 +163,7 @@ public abstract class AbstractLinkedListTest<E> extends AbstractListTest<E> {
         } catch (final IndexOutOfBoundsException ex) {
             // expected
         }
-         try {
+        try {
             list.getNode(3, true);
             fail("Expecting IndexOutOfBoundsException.");
         } catch (final IndexOutOfBoundsException ex) {
diff --git a/src/test/java/org/apache/commons/collections4/list/AbstractListTest.java b/src/test/java/org/apache/commons/collections4/list/AbstractListTest.java
index d051778..b0b55e7 100644
--- a/src/test/java/org/apache/commons/collections4/list/AbstractListTest.java
+++ b/src/test/java/org/apache/commons/collections4/list/AbstractListTest.java
@@ -498,7 +498,7 @@ public abstract class AbstractListTest<E> extends AbstractCollectionTest<E> {
         while (iterator.hasNext()) {
             final E element = iterator.next();
             assertEquals("lastIndexOf should return correct result",
-              list1.lastIndexOf(element), list2.lastIndexOf(element));
+                list1.lastIndexOf(element), list2.lastIndexOf(element));
             verify();
         }
 
@@ -574,7 +574,7 @@ public abstract class AbstractListTest<E> extends AbstractCollectionTest<E> {
         try {
             list.set(Integer.MIN_VALUE, element);
             fail("List.set should throw IndexOutOfBoundsException " +
-              "[Integer.MIN_VALUE]");
+                "[Integer.MIN_VALUE]");
         } catch(final IndexOutOfBoundsException e) {
             // expected
         }
@@ -596,7 +596,7 @@ public abstract class AbstractListTest<E> extends AbstractCollectionTest<E> {
         try {
             list.set(Integer.MAX_VALUE, element);
             fail("List.set should throw IndexOutOfBoundsException " +
-              "[Integer.MAX_VALUE]");
+                "[Integer.MAX_VALUE]");
         } catch(final IndexOutOfBoundsException e) {
             // expected
         }
@@ -706,7 +706,7 @@ public abstract class AbstractListTest<E> extends AbstractCollectionTest<E> {
         try {
             list.remove(Integer.MIN_VALUE);
             fail("List.remove should throw IndexOutOfBoundsException " +
-              "[Integer.MIN_VALUE]");
+                "[Integer.MIN_VALUE]");
         } catch(final IndexOutOfBoundsException e) {
             // expected
         }
@@ -728,7 +728,7 @@ public abstract class AbstractListTest<E> extends AbstractCollectionTest<E> {
         try {
             list.remove(Integer.MAX_VALUE);
             fail("List.remove should throw IndexOutOfBoundsException " +
-              "[Integer.MAX_VALUE]");
+                "[Integer.MAX_VALUE]");
         } catch(final IndexOutOfBoundsException e) {
             // expected
         }
@@ -1135,254 +1135,253 @@ public abstract class AbstractListTest<E> extends AbstractCollectionTest<E> {
         return new BulkTestSubList<>(this);
     }
 
-   public static class BulkTestSubList<E> extends AbstractListTest<E> {
-
-       private final AbstractListTest<E> outer;
-
-       public BulkTestSubList(final AbstractListTest<E> outer) {
-           super("");
-           this.outer = outer;
-       }
-
-       @Override
-       @SuppressWarnings("unchecked")
-       public E[] getFullElements() {
-           final List<E> l = Arrays.asList(outer.getFullElements());
-           return (E[]) l.subList(3, l.size() - 3).toArray();
-       }
-
-       @Override
-       public E[] getOtherElements() {
-           return outer.getOtherElements();
-       }
-
-       @Override
-       public boolean isAddSupported() {
-           return outer.isAddSupported();
-       }
-
-       @Override
-       public boolean isSetSupported() {
-           return outer.isSetSupported();
-       }
-
-       @Override
-       public boolean isRemoveSupported() {
-           return outer.isRemoveSupported();
-       }
-
-       @Override
-       public List<E> makeObject() {
-           return outer.makeFullCollection().subList(4, 4);
-       }
-
-       @Override
-       public List<E> makeFullCollection() {
-           final int size = getFullElements().length;
-           return outer.makeFullCollection().subList(3, size - 3);
-       }
-
-       @Override
-       public void resetEmpty() {
-           outer.resetFull();
-           this.setCollection(outer.getCollection().subList(4, 4));
-           this.setConfirmed(outer.getConfirmed().subList(4, 4));
-       }
-
-       @Override
-       public void resetFull() {
-           outer.resetFull();
-           final int size = outer.getConfirmed().size();
-           this.setCollection(outer.getCollection().subList(3, size - 3));
-           this.setConfirmed(outer.getConfirmed().subList(3, size - 3));
-       }
-
-       @Override
-       public void verify() {
-           super.verify();
-           outer.verify();
-       }
-
-       @Override
-       public boolean isTestSerialization() {
-           return false;
-       }
-   }
-
-   /**
-    *  Tests that a sublist raises a {@link java.util.ConcurrentModificationException ConcurrentModificationException}
-    *  if elements are added to the original list.
-    */
-   public void testListSubListFailFastOnAdd() {
-       if (!isFailFastSupported()) {
-        return;
+    public static class BulkTestSubList<E> extends AbstractListTest<E> {
+
+        private final AbstractListTest<E> outer;
+
+        public BulkTestSubList(final AbstractListTest<E> outer) {
+            super("");
+            this.outer = outer;
+        }
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public E[] getFullElements() {
+            final List<E> l = Arrays.asList(outer.getFullElements());
+            return (E[]) l.subList(3, l.size() - 3).toArray();
+        }
+
+        @Override
+        public E[] getOtherElements() {
+            return outer.getOtherElements();
+        }
+
+        @Override
+        public boolean isAddSupported() {
+            return outer.isAddSupported();
+        }
+
+        @Override
+        public boolean isSetSupported() {
+            return outer.isSetSupported();
+        }
+
+        @Override
+        public boolean isRemoveSupported() {
+            return outer.isRemoveSupported();
+        }
+
+        @Override
+        public List<E> makeObject() {
+            return outer.makeFullCollection().subList(4, 4);
+        }
+
+        @Override
+        public List<E> makeFullCollection() {
+            final int size = getFullElements().length;
+            return outer.makeFullCollection().subList(3, size - 3);
+        }
+
+        @Override
+        public void resetEmpty() {
+            outer.resetFull();
+            this.setCollection(outer.getCollection().subList(4, 4));
+            this.setConfirmed(outer.getConfirmed().subList(4, 4));
+        }
+
+        @Override
+        public void resetFull() {
+            outer.resetFull();
+            final int size = outer.getConfirmed().size();
+            this.setCollection(outer.getCollection().subList(3, size - 3));
+            this.setConfirmed(outer.getConfirmed().subList(3, size - 3));
+        }
+
+        @Override
+        public void verify() {
+            super.verify();
+            outer.verify();
+        }
+
+        @Override
+        public boolean isTestSerialization() {
+            return false;
+        }
     }
-       if (!isAddSupported()) {
-        return;
+
+    /**
+     * Tests that a sublist raises a {@link java.util.ConcurrentModificationException ConcurrentModificationException}
+     * if elements are added to the original list.
+     */
+    public void testListSubListFailFastOnAdd() {
+        if (!isFailFastSupported()) {
+            return;
+        }
+        if (!isAddSupported()) {
+            return;
+        }
+
+        resetFull();
+        final int size = getCollection().size();
+        List<E> sub = getCollection().subList(1, size);
+        getCollection().add(getOtherElements()[0]);
+        failFastAll(sub);
+
+        resetFull();
+        sub = getCollection().subList(1, size);
+        getCollection().add(0, getOtherElements()[0]);
+        failFastAll(sub);
+
+        resetFull();
+        sub = getCollection().subList(1, size);
+        getCollection().addAll(Arrays.asList(getOtherElements()));
+        failFastAll(sub);
+
+        resetFull();
+        sub = getCollection().subList(1, size);
+        getCollection().addAll(0, Arrays.asList(getOtherElements()));
+        failFastAll(sub);
     }
 
-       resetFull();
-       final int size = getCollection().size();
-       List<E> sub = getCollection().subList(1, size);
-       getCollection().add(getOtherElements()[0]);
-       failFastAll(sub);
-
-       resetFull();
-       sub = getCollection().subList(1, size);
-       getCollection().add(0, getOtherElements()[0]);
-       failFastAll(sub);
-
-       resetFull();
-       sub = getCollection().subList(1, size);
-       getCollection().addAll(Arrays.asList(getOtherElements()));
-       failFastAll(sub);
-
-       resetFull();
-       sub = getCollection().subList(1, size);
-       getCollection().addAll(0, Arrays.asList(getOtherElements()));
-       failFastAll(sub);
-   }
-
-   /**
-    *  Tests that a sublist raises a {@link java.util.ConcurrentModificationException ConcurrentModificationException}
-    *  if elements are removed from the original list.
-    */
-   public void testListSubListFailFastOnRemove() {
-       if (!isFailFastSupported()) {
-        return;
+    /**
+     * Tests that a sublist raises a {@link java.util.ConcurrentModificationException ConcurrentModificationException}
+     * if elements are removed from the original list.
+     */
+    public void testListSubListFailFastOnRemove() {
+        if (!isFailFastSupported()) {
+            return;
+        }
+        if (!isRemoveSupported()) {
+            return;
+        }
+
+        resetFull();
+        final int size = getCollection().size();
+        List<E> sub = getCollection().subList(1, size);
+        getCollection().remove(0);
+        failFastAll(sub);
+
+        resetFull();
+        sub = getCollection().subList(1, size);
+        getCollection().remove(getFullElements()[2]);
+        failFastAll(sub);
+
+        resetFull();
+        sub = getCollection().subList(1, size);
+        getCollection().removeAll(Arrays.asList(getFullElements()));
+        failFastAll(sub);
+
+        resetFull();
+        sub = getCollection().subList(1, size);
+        getCollection().retainAll(Arrays.asList(getOtherElements()));
+        failFastAll(sub);
+
+        resetFull();
+        sub = getCollection().subList(1, size);
+        getCollection().clear();
+        failFastAll(sub);
     }
-       if (!isRemoveSupported()) {
-        return;
+
+    /**
+     * Invokes all the methods on the given sublist to make sure they raise
+     * a {@link java.util.ConcurrentModificationException ConcurrentModificationException}.
+     */
+    protected void failFastAll(final List<E> list) {
+        final Method[] methods = List.class.getMethods();
+        for (final Method method : methods) {
+            failFastMethod(list, method);
+        }
+    }
+
+    /**
+     * Invokes the given method on the given sublist to make sure it raises
+     * a {@link java.util.ConcurrentModificationException ConcurrentModificationException}.
+     *
+     * Unless the method happens to be the equals() method, in which case
+     * the test is skipped. There seems to be a bug in
+     * java.util.AbstractList.subList(int,int).equals(Object) -- it never
+     * raises a ConcurrentModificationException.
+     *
+     * @param list the sublist to test
+     * @param m the method to invoke
+     */
+    protected void failFastMethod(final List<E> list, final Method m) {
+        if (m.getName().equals("equals")) {
+            return;
+        }
+
+        final E element = getOtherElements()[0];
+        final Collection<E> c = Collections.singleton(element);
+
+        final Class<?>[] types = m.getParameterTypes();
+        final Object[] params = new Object[types.length];
+        for (int i = 0; i < params.length; i++) {
+            if (types[i] == Integer.TYPE) {
+                params[i] = Integer.valueOf(0);
+            } else if (types[i] == Collection.class) {
+                params[i] = c;
+            } else if (types[i] == Object.class) {
+                params[i] = element;
+            } else if (types[i] == Object[].class) {
+                params[i] = new Object[0];
+            }
+        }
+
+        try {
+            m.invoke(list, params);
+            fail(m.getName() + " should raise ConcurrentModification");
+        } catch (final IllegalAccessException e) {
+            // impossible
+        } catch (final InvocationTargetException e) {
+            final Throwable t = e.getTargetException();
+            if (t instanceof ConcurrentModificationException) {
+                // expected
+                return;
+            }
+            fail(m.getName() + " raised unexpected " + e);
+        }
     }
 
-       resetFull();
-       final int size = getCollection().size();
-       List<E> sub = getCollection().subList(1, size);
-       getCollection().remove(0);
-       failFastAll(sub);
-
-       resetFull();
-       sub = getCollection().subList(1, size);
-       getCollection().remove(getFullElements()[2]);
-       failFastAll(sub);
-
-       resetFull();
-       sub = getCollection().subList(1, size);
-       getCollection().removeAll(Arrays.asList(getFullElements()));
-       failFastAll(sub);
-
-       resetFull();
-       sub = getCollection().subList(1, size);
-       getCollection().retainAll(Arrays.asList(getOtherElements()));
-       failFastAll(sub);
-
-       resetFull();
-       sub = getCollection().subList(1, size);
-       getCollection().clear();
-       failFastAll(sub);
-   }
-
-   /**
-    *  Invokes all the methods on the given sublist to make sure they raise
-    *  a {@link java.util.ConcurrentModificationException ConcurrentModificationException}.
-    */
-   protected void failFastAll(final List<E> list) {
-       final Method[] methods = List.class.getMethods();
-       for (final Method method : methods) {
-           failFastMethod(list, method);
-       }
-   }
-
-   /**
-    *  Invokes the given method on the given sublist to make sure it raises
-    *  a {@link java.util.ConcurrentModificationException ConcurrentModificationException}.
-    *
-    *  Unless the method happens to be the equals() method, in which case
-    *  the test is skipped.  There seems to be a bug in
-    *  java.util.AbstractList.subList(int,int).equals(Object) -- it never
-    *  raises a ConcurrentModificationException.
-    *
-    *  @param list  the sublist to test
-    *  @param m     the method to invoke
-    */
-   protected void failFastMethod(final List<E> list, final Method m) {
-       if (m.getName().equals("equals")) {
-        return;
+    // -----------------------------------------------------------------------
+    public BulkTest bulkTestListIterator() {
+        return new TestListIterator();
     }
 
-       final E element = getOtherElements()[0];
-       final Collection<E> c = Collections.singleton(element);
-
-       final Class<?>[] types = m.getParameterTypes();
-       final Object[] params = new Object[types.length];
-       for (int i = 0; i < params.length; i++) {
-           if (types[i] == Integer.TYPE) {
-            params[i] = Integer.valueOf(0);
-        } else if (types[i] == Collection.class) {
-            params[i] = c;
-        } else if (types[i] == Object.class) {
-            params[i] = element;
-        } else if (types[i] == Object[].class) {
-            params[i] = new Object[0];
-        }
-       }
-
-       try {
-           m.invoke(list, params);
-           fail(m.getName() + " should raise ConcurrentModification");
-       } catch (final IllegalAccessException e) {
-           // impossible
-       } catch (final InvocationTargetException e) {
-           final Throwable t = e.getTargetException();
-           if (t instanceof ConcurrentModificationException) {
-               // expected
-               return;
-           }
-        fail(m.getName() + " raised unexpected " + e);
-       }
-   }
-
-   //-----------------------------------------------------------------------
-   public BulkTest bulkTestListIterator() {
-       return new TestListIterator();
-   }
-
-   public class TestListIterator extends AbstractListIteratorTest<E> {
-       public TestListIterator() {
-           super("TestListIterator");
-       }
-
-       @Override
-       public E addSetValue() {
-           return AbstractListTest.this.getOtherElements()[0];
-       }
-
-       @Override
-       public boolean supportsRemove() {
-           return AbstractListTest.this.isRemoveSupported();
-       }
-
-       @Override
-       public boolean supportsAdd() {
-           return AbstractListTest.this.isAddSupported();
-       }
-
-       @Override
-       public boolean supportsSet() {
-           return AbstractListTest.this.isSetSupported();
-       }
-
-       @Override
-       public ListIterator<E> makeEmptyIterator() {
-           resetEmpty();
-           return AbstractListTest.this.getCollection().listIterator();
-       }
-
-       @Override
-       public ListIterator<E> makeObject() {
-           resetFull();
-           return AbstractListTest.this.getCollection().listIterator();
-       }
-   }
+    public class TestListIterator extends AbstractListIteratorTest<E> {
+        public TestListIterator() {
+            super("TestListIterator");
+        }
+
+        @Override
+        public E addSetValue() {
+            return AbstractListTest.this.getOtherElements()[0];
+        }
 
+        @Override
+        public boolean supportsRemove() {
+            return AbstractListTest.this.isRemoveSupported();
+        }
+
+        @Override
+        public boolean supportsAdd() {
+            return AbstractListTest.this.isAddSupported();
+        }
+
+        @Override
+        public boolean supportsSet() {
+            return AbstractListTest.this.isSetSupported();
+        }
+
+        @Override
+        public ListIterator<E> makeEmptyIterator() {
+            resetEmpty();
+            return AbstractListTest.this.getCollection().listIterator();
+        }
+
+        @Override
+        public ListIterator<E> makeObject() {
+            resetFull();
+            return AbstractListTest.this.getCollection().listIterator();
+        }
+    }
 }
diff --git a/src/test/java/org/apache/commons/collections4/list/CursorableLinkedListTest.java b/src/test/java/org/apache/commons/collections4/list/CursorableLinkedListTest.java
index f959fb5..b0e4d8e 100644
--- a/src/test/java/org/apache/commons/collections4/list/CursorableLinkedListTest.java
+++ b/src/test/java/org/apache/commons/collections4/list/CursorableLinkedListTest.java
@@ -1504,14 +1504,14 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
         final String prefix = "CursorableLinkedListTest";
         final String bulk = ".bulkTestSubList";
         final String[] ignored = new String[] {
-                ".testEmptyListSerialization",
-                ".testFullListSerialization",
-                ".testEmptyListCompatibility",
-                ".testFullListCompatibility",
-                ".testSimpleSerialization",
-                ".testCanonicalEmptyCollectionExists",
-                ".testCanonicalFullCollectionExists",
-                ".testSerializeDeserializeThenCompare"
+            ".testEmptyListSerialization",
+            ".testFullListSerialization",
+            ".testEmptyListCompatibility",
+            ".testFullListCompatibility",
+            ".testSimpleSerialization",
+            ".testCanonicalEmptyCollectionExists",
+            ".testCanonicalFullCollectionExists",
+            ".testSerializeDeserializeThenCompare"
         };
         for (final String element : ignored) {
             list.add(prefix + bulk + element);
diff --git a/src/test/java/org/apache/commons/collections4/list/PredicatedListTest.java b/src/test/java/org/apache/commons/collections4/list/PredicatedListTest.java
index 1390b2b..88e60eb 100644
--- a/src/test/java/org/apache/commons/collections4/list/PredicatedListTest.java
+++ b/src/test/java/org/apache/commons/collections4/list/PredicatedListTest.java
@@ -72,8 +72,7 @@ public class PredicatedListTest<E> extends AbstractListTest<E> {
         } catch (final IllegalArgumentException e) {
             // expected
         }
-        assertTrue("Collection shouldn't contain illegal element",
-         !list.contains(i));
+        assertTrue("Collection shouldn't contain illegal element", !list.contains(i));
     }
 
     @SuppressWarnings("unchecked")
@@ -90,14 +89,10 @@ public class PredicatedListTest<E> extends AbstractListTest<E> {
         } catch (final IllegalArgumentException e) {
             // expected
         }
-        assertTrue("List shouldn't contain illegal element",
-         !list.contains("one"));
-        assertTrue("List shouldn't contain illegal element",
-         !list.contains("two"));
-        assertTrue("List shouldn't contain illegal element",
-         !list.contains(Integer.valueOf(3)));
-        assertTrue("List shouldn't contain illegal element",
-         !list.contains("four"));
+        assertTrue("List shouldn't contain illegal element", !list.contains("one"));
+        assertTrue("List shouldn't contain illegal element", !list.contains("two"));
+        assertTrue("List shouldn't contain illegal element", !list.contains(Integer.valueOf(3)));
+        assertTrue("List shouldn't contain illegal element", !list.contains("four"));
     }
 
     @SuppressWarnings("unchecked")
@@ -120,14 +115,10 @@ public class PredicatedListTest<E> extends AbstractListTest<E> {
         elements.add((E) "two");
         elements.add((E) "three");
         list.addAll(1, elements);
-        assertTrue("List should contain legal element",
-         list.contains("zero"));
-        assertTrue("List should contain legal element",
-         list.contains("one"));
-        assertTrue("List should contain legal element",
-         list.contains("two"));
-        assertTrue("List should contain legal element",
-         list.contains("three"));
+        assertTrue("List should contain legal element", list.contains("zero"));
+        assertTrue("List should contain legal element", list.contains("one"));
+        assertTrue("List should contain legal element", list.contains("two"));
+        assertTrue("List should contain legal element", list.contains("three"));
     }
 
     public void testSubList() {
diff --git a/src/test/java/org/apache/commons/collections4/list/SetUniqueListTest.java b/src/test/java/org/apache/commons/collections4/list/SetUniqueListTest.java
index 8638a31..05795e9 100644
--- a/src/test/java/org/apache/commons/collections4/list/SetUniqueListTest.java
+++ b/src/test/java/org/apache/commons/collections4/list/SetUniqueListTest.java
@@ -60,23 +60,23 @@ public class SetUniqueListTest<E> extends AbstractListTest<E> {
     public E[] getFullNonNullElements() {
         // override to avoid duplicate "One"
         return (E[]) new Object[] {
-                new String(""),
-                new String("One"),
-                Integer.valueOf(2),
-                "Three",
-                Integer.valueOf(4),
-                new Double(5),
-                new Float(6),
-                "Seven",
-                "Eight",
-                new String("Nine"),
-                Integer.valueOf(10),
-                new Short((short) 11),
-                new Long(12),
-                "Thirteen",
-                "14",
-                "15",
-                new Byte((byte) 16)
+            new String(""),
+            new String("One"),
+            Integer.valueOf(2),
+            "Three",
+            Integer.valueOf(4),
+            new Double(5),
+            new Float(6),
+            "Seven",
+            "Eight",
+            new String("Nine"),
+            Integer.valueOf(10),
+            new Short((short) 11),
+            new Long(12),
+            "Thirteen",
+            "14",
+            "15",
+            new Byte((byte) 16)
         };
     }
 
@@ -252,28 +252,28 @@ public class SetUniqueListTest<E> extends AbstractListTest<E> {
     }
 
     public void testIntCollectionAddAll() {
-      // make a SetUniqueList with one element
-      final List<Integer> list = new SetUniqueList<>(new ArrayList<Integer>(), new HashSet<Integer>());
-      final Integer existingElement = Integer.valueOf(1);
-      list.add(existingElement);
-
-      // add two new unique elements at index 0
-      final Integer firstNewElement = Integer.valueOf(2);
-      final Integer secondNewElement = Integer.valueOf(3);
-      Collection<Integer> collection = Arrays.asList(firstNewElement, secondNewElement);
-      list.addAll(0, collection);
-      assertEquals("Unique elements should be added.", 3, list.size());
-      assertEquals("First new element should be at index 0", firstNewElement, list.get(0));
-      assertEquals("Second new element should be at index 1", secondNewElement, list.get(1));
-      assertEquals("Existing element should shift to index 2", existingElement, list.get(2));
-
-      // add a duplicate element and a unique element at index 0
-      final Integer thirdNewElement = Integer.valueOf(4);
-      collection = Arrays.asList(existingElement, thirdNewElement);
-      list.addAll(0, collection);
-      assertEquals("Duplicate element should not be added, unique element should be added.",
-        4, list.size());
-      assertEquals("Third new element should be at index 0", thirdNewElement, list.get(0));
+        // make a SetUniqueList with one element
+        final List<Integer> list = new SetUniqueList<>(new ArrayList<Integer>(), new HashSet<Integer>());
+        final Integer existingElement = Integer.valueOf(1);
+        list.add(existingElement);
+
+        // add two new unique elements at index 0
+        final Integer firstNewElement = Integer.valueOf(2);
+        final Integer secondNewElement = Integer.valueOf(3);
+        Collection<Integer> collection = Arrays.asList(firstNewElement, secondNewElement);
+        list.addAll(0, collection);
+        assertEquals("Unique elements should be added.", 3, list.size());
+        assertEquals("First new element should be at index 0", firstNewElement, list.get(0));
+        assertEquals("Second new element should be at index 1", secondNewElement, list.get(1));
+        assertEquals("Existing element should shift to index 2", existingElement, list.get(2));
+
+        // add a duplicate element and a unique element at index 0
+        final Integer thirdNewElement = Integer.valueOf(4);
+        collection = Arrays.asList(existingElement, thirdNewElement);
+        list.addAll(0, collection);
+        assertEquals("Duplicate element should not be added, unique element should be added.",
+            4, list.size());
+        assertEquals("Third new element should be at index 0", thirdNewElement, list.get(0));
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/test/java/org/apache/commons/collections4/list/UnmodifiableListTest.java b/src/test/java/org/apache/commons/collections4/list/UnmodifiableListTest.java
index d5a50cd..670f175 100644
--- a/src/test/java/org/apache/commons/collections4/list/UnmodifiableListTest.java
+++ b/src/test/java/org/apache/commons/collections4/list/UnmodifiableListTest.java
@@ -101,55 +101,55 @@ public class UnmodifiableListTest<E> extends AbstractListTest<E> {
         }
         try {
             list.add((E) Integer.valueOf(0));
-             fail("Expecting UnsupportedOperationException.");
+            fail("Expecting UnsupportedOperationException.");
         } catch (final UnsupportedOperationException e) {
             // expected
         }
         try {
             list.addAll(0, array);
-             fail("Expecting UnsupportedOperationException.");
+            fail("Expecting UnsupportedOperationException.");
         } catch (final UnsupportedOperationException e) {
             // expected
         }
         try {
             list.addAll(array);
-             fail("Expecting UnsupportedOperationException.");
+            fail("Expecting UnsupportedOperationException.");
         } catch (final UnsupportedOperationException e) {
             // expected
         }
         try {
             list.clear();
-             fail("Expecting UnsupportedOperationException.");
+            fail("Expecting UnsupportedOperationException.");
         } catch (final UnsupportedOperationException e) {
             // expected
         }
         try {
             list.remove(0);
-             fail("Expecting UnsupportedOperationException.");
+            fail("Expecting UnsupportedOperationException.");
         } catch (final UnsupportedOperationException e) {
             // expected
         }
         try {
             list.remove(Integer.valueOf(0));
-             fail("Expecting UnsupportedOperationException.");
+            fail("Expecting UnsupportedOperationException.");
         } catch (final UnsupportedOperationException e) {
             // expected
         }
         try {
             list.removeAll(array);
-             fail("Expecting UnsupportedOperationException.");
+            fail("Expecting UnsupportedOperationException.");
         } catch (final UnsupportedOperationException e) {
             // expected
         }
         try {
             list.retainAll(array);
-             fail("Expecting UnsupportedOperationException.");
+            fail("Expecting UnsupportedOperationException.");
         } catch (final UnsupportedOperationException e) {
             // expected
         }
         try {
             list.set(0, (E) Integer.valueOf(0));
-             fail("Expecting UnsupportedOperationException.");
+            fail("Expecting UnsupportedOperationException.");
         } catch (final UnsupportedOperationException e) {
             // expected
         }
diff --git a/src/test/java/org/apache/commons/collections4/map/CompositeMapTest.java b/src/test/java/org/apache/commons/collections4/map/CompositeMapTest.java
index 4499eb2..967dfd2 100644
--- a/src/test/java/org/apache/commons/collections4/map/CompositeMapTest.java
+++ b/src/test/java/org/apache/commons/collections4/map/CompositeMapTest.java
@@ -134,27 +134,27 @@ public class CompositeMapTest<K, V> extends AbstractIterableMapTest<K, V> {
     public void testResolveCollision() {
         final CompositeMap<K, V> map = new CompositeMap<>(buildOne(), buildTwo(),
             new CompositeMap.MapMutator<K, V>() {
-            private static final long serialVersionUID = 1L;
-
-            @Override
-            public void resolveCollision(final CompositeMap<K, V> composite,
-            final Map<K, V> existing,
-            final Map<K, V> added,
-            final Collection<K> intersect) {
-                pass = true;
-            }
-
-            @Override
-            public V put(final CompositeMap<K, V> map, final Map<K, V>[] composited, final K key,
-                final V value) {
-                throw new UnsupportedOperationException();
-            }
-
-            @Override
-            public void putAll(final CompositeMap<K, V> map, final Map<K, V>[] composited, final Map<? extends K, ? extends V> t) {
-                throw new UnsupportedOperationException();
-            }
-        });
+                private static final long serialVersionUID = 1L;
+
+                @Override
+                public void resolveCollision(final CompositeMap<K, V> composite,
+                    final Map<K, V> existing,
+                    final Map<K, V> added,
+                    final Collection<K> intersect) {
+                    pass = true;
+                }
+
+                @Override
+                public V put(final CompositeMap<K, V> map, final Map<K, V>[] composited, final K key,
+                    final V value) {
+                    throw new UnsupportedOperationException();
+                }
+
+                @Override
+                public void putAll(final CompositeMap<K, V> map, final Map<K, V>[] composited, final Map<? extends K, ? extends V> t) {
+                    throw new UnsupportedOperationException();
+                }
+            });
 
         map.addComposited(buildOne());
         assertTrue(pass);
@@ -164,27 +164,27 @@ public class CompositeMapTest<K, V> extends AbstractIterableMapTest<K, V> {
     public void testPut() {
         final CompositeMap<K, V> map = new CompositeMap<>(buildOne(), buildTwo(),
             new CompositeMap.MapMutator<K, V>() {
-            private static final long serialVersionUID = 1L;
-            @Override
-            public void resolveCollision(final CompositeMap<K, V> composite,
-            final Map<K, V> existing,
-            final Map<K, V> added,
-            final Collection<K> intersect) {
-                throw new UnsupportedOperationException();
-            }
-
-            @Override
-            public V put(final CompositeMap<K, V> map, final Map<K, V>[] composited, final K key,
-                final V value) {
-                pass = true;
-                return (V) "foo";
-            }
-
-            @Override
-            public void putAll(final CompositeMap<K, V> map, final Map<K, V>[] composited, final Map<? extends K, ? extends V> t) {
-                throw new UnsupportedOperationException();
-            }
-        });
+                private static final long serialVersionUID = 1L;
+                @Override
+                public void resolveCollision(final CompositeMap<K, V> composite,
+                    final Map<K, V> existing,
+                    final Map<K, V> added,
+                    final Collection<K> intersect) {
+                    throw new UnsupportedOperationException();
+                }
+
+                @Override
+                public V put(final CompositeMap<K, V> map, final Map<K, V>[] composited, final K key,
+                    final V value) {
+                    pass = true;
+                    return (V) "foo";
+                }
+
+                @Override
+                public void putAll(final CompositeMap<K, V> map, final Map<K, V>[] composited, final Map<? extends K, ? extends V> t) {
+                    throw new UnsupportedOperationException();
+                }
+            });
 
         map.put((K) "willy", (V) "wonka");
         assertTrue(pass);
@@ -193,26 +193,26 @@ public class CompositeMapTest<K, V> extends AbstractIterableMapTest<K, V> {
     public void testPutAll() {
         final CompositeMap<K, V> map = new CompositeMap<>(buildOne(), buildTwo(),
             new CompositeMap.MapMutator<K, V>() {
-            private static final long serialVersionUID = 1L;
-            @Override
-            public void resolveCollision(final CompositeMap<K, V> composite,
-            final Map<K, V> existing,
-            final Map<K, V> added,
-            final Collection<K> intersect) {
-                throw new UnsupportedOperationException();
-            }
-
-            @Override
-            public V put(final CompositeMap<K, V> map, final Map<K, V>[] composited, final K key,
-                final V value) {
-                throw new UnsupportedOperationException();
-            }
-
-            @Override
-            public void putAll(final CompositeMap<K, V> map, final Map<K, V>[] composited, final Map<? extends K, ? extends V> t) {
-                pass = true;
-            }
-        });
+                private static final long serialVersionUID = 1L;
+                @Override
+                public void resolveCollision(final CompositeMap<K, V> composite,
+                    final Map<K, V> existing,
+                    final Map<K, V> added,
+                    final Collection<K> intersect) {
+                    throw new UnsupportedOperationException();
+                }
+
+                @Override
+                public V put(final CompositeMap<K, V> map, final Map<K, V>[] composited, final K key,
+                    final V value) {
+                    throw new UnsupportedOperationException();
+                }
+
+                @Override
+                public void putAll(final CompositeMap<K, V> map, final Map<K, V>[] composited, final Map<? extends K, ? extends V> t) {
+                    pass = true;
+                }
+            });
 
         map.putAll(null);
         assertTrue(pass);
diff --git a/src/test/java/org/apache/commons/collections4/map/DefaultedMapTest.java b/src/test/java/org/apache/commons/collections4/map/DefaultedMapTest.java
index 2a9fd37..01faad3 100644
--- a/src/test/java/org/apache/commons/collections4/map/DefaultedMapTest.java
+++ b/src/test/java/org/apache/commons/collections4/map/DefaultedMapTest.java
@@ -129,44 +129,44 @@ public class DefaultedMapTest<K, V> extends AbstractIterableMapTest<K, V> {
         assertEquals("NULL_OBJECT", map.get(Integer.valueOf(0)));
     }
 
-     public void testFactoryMethods() {
-         final HashMap<K, V> base = new HashMap<>();
-
-         try {
-             DefaultedMap.defaultedMap(null, (V) "DEFAULT_VALUE");
-             fail("Expecting NullPointerException");
-         } catch (final NullPointerException e) {
-             // Expected
-         }
-
-         try {
-             DefaultedMap.defaultedMap((Map<K, V>) null, nullFactory);
-             fail("Expecting NullPointerException");
-         } catch (final NullPointerException e) {
-             // Expected
-         }
-
-         try {
-             DefaultedMap.defaultedMap(base, (Factory<V>) null);
-             fail("Expecting NullPointerException");
-         } catch (final NullPointerException e) {
-             // Expected
-         }
-
-         try {
-             DefaultedMap.defaultedMap((Map<K, V>) null, nullTransformer);
-             fail("Expecting NullPointerException");
-         } catch (final NullPointerException e) {
-             // Expected
-         }
-
-         try {
-             DefaultedMap.defaultedMap(base, (Transformer<K, V>) null);
-             fail("Expecting NullPointerException");
-         } catch (final NullPointerException e) {
-             // Expected
-         }
-     }
+    public void testFactoryMethods() {
+        final HashMap<K, V> base = new HashMap<>();
+
+        try {
+            DefaultedMap.defaultedMap(null, (V) "DEFAULT_VALUE");
+            fail("Expecting NullPointerException");
+        } catch (final NullPointerException e) {
+            // Expected
+        }
+
+        try {
+            DefaultedMap.defaultedMap((Map<K, V>) null, nullFactory);
+            fail("Expecting NullPointerException");
+        } catch (final NullPointerException e) {
+            // Expected
+        }
+
+        try {
+            DefaultedMap.defaultedMap(base, (Factory<V>) null);
+            fail("Expecting NullPointerException");
+        } catch (final NullPointerException e) {
+            // Expected
+        }
+
+        try {
+            DefaultedMap.defaultedMap((Map<K, V>) null, nullTransformer);
+            fail("Expecting NullPointerException");
+        } catch (final NullPointerException e) {
+            // Expected
+        }
+
+        try {
+            DefaultedMap.defaultedMap(base, (Transformer<K, V>) null);
+            fail("Expecting NullPointerException");
+        } catch (final NullPointerException e) {
+            // Expected
+        }
+    }
 
     @Override
     public String getCompatibilityVersion() {
diff --git a/src/test/java/org/apache/commons/collections4/map/EmptyMapMutator.java b/src/test/java/org/apache/commons/collections4/map/EmptyMapMutator.java
index a41e8c0..e3002a3 100644
--- a/src/test/java/org/apache/commons/collections4/map/EmptyMapMutator.java
+++ b/src/test/java/org/apache/commons/collections4/map/EmptyMapMutator.java
@@ -30,9 +30,9 @@ class EmptyMapMutator<K, V> implements CompositeMap.MapMutator<K, V> {
 
     @Override
     public void resolveCollision(final CompositeMap<K, V> composite,
-    final Map<K, V> existing,
-    final Map<K, V> added,
-    final Collection<K> intersect) {
+        final Map<K, V> existing,
+        final Map<K, V> added,
+        final Collection<K> intersect) {
         // Do nothing
     }
 
diff --git a/src/test/java/org/apache/commons/collections4/map/LazySortedMapTest.java b/src/test/java/org/apache/commons/collections4/map/LazySortedMapTest.java
index 2ae2377..29f3e04 100644
--- a/src/test/java/org/apache/commons/collections4/map/LazySortedMapTest.java
+++ b/src/test/java/org/apache/commons/collections4/map/LazySortedMapTest.java
@@ -129,7 +129,7 @@ public class LazySortedMapTest<K, V> extends AbstractSortedMapTest<K, V> {
         final Transformer<Object, Integer> transformer = TransformerUtils.asTransformer(oneFactory);
         SortedMap<Integer, Number> map = lazySortedMap(new TreeMap<Integer, Number>(), transformer);
         assertTrue(map instanceof LazySortedMap);
-         try {
+        try {
             map = lazySortedMap(new TreeMap<Integer, Number>(), (Transformer<Integer, Number>) null);
             fail("Expecting NullPointerException for null transformer");
         } catch (final NullPointerException e) {
diff --git a/src/test/java/org/apache/commons/collections4/map/MultiKeyMapTest.java b/src/test/java/org/apache/commons/collections4/map/MultiKeyMapTest.java
index 0cd1c5a..dbac088 100644
--- a/src/test/java/org/apache/commons/collections4/map/MultiKeyMapTest.java
+++ b/src/test/java/org/apache/commons/collections4/map/MultiKeyMapTest.java
@@ -147,7 +147,7 @@ public class MultiKeyMapTest<K, V> extends AbstractIterableMapTest<MultiKey<? ex
             final V value = values[i];
 
             switch (key.size()) {
-                case 2:
+            case 2:
                 assertEquals(value, multimap.get(key.getKey(0), key.getKey(1)));
                 assertEquals(null, multimap.get(null, key.getKey(1)));
                 assertEquals(null, multimap.get(key.getKey(0), null));
@@ -156,7 +156,7 @@ public class MultiKeyMapTest<K, V> extends AbstractIterableMapTest<MultiKey<? ex
                 assertEquals(null, multimap.get(key.getKey(0), key.getKey(1), null, null));
                 assertEquals(null, multimap.get(key.getKey(0), key.getKey(1), null, null, null));
                 break;
-                case 3:
+            case 3:
                 assertEquals(value, multimap.get(key.getKey(0), key.getKey(1), key.getKey(2)));
                 assertEquals(null, multimap.get(null, key.getKey(1), key.getKey(2)));
                 assertEquals(null, multimap.get(key.getKey(0), null, key.getKey(2)));
@@ -165,7 +165,7 @@ public class MultiKeyMapTest<K, V> extends AbstractIterableMapTest<MultiKey<? ex
                 assertEquals(null, multimap.get(key.getKey(0), key.getKey(1), key.getKey(2), null));
                 assertEquals(null, multimap.get(key.getKey(0), key.getKey(1), key.getKey(2), null, null));
                 break;
-                case 4:
+            case 4:
                 assertEquals(value, multimap.get(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3)));
                 assertEquals(null, multimap.get(null, key.getKey(1), key.getKey(2), key.getKey(3)));
                 assertEquals(null, multimap.get(key.getKey(0), null, key.getKey(2), key.getKey(3)));
@@ -174,7 +174,7 @@ public class MultiKeyMapTest<K, V> extends AbstractIterableMapTest<MultiKey<? ex
                 assertEquals(null, multimap.get(null, null, null, null));
                 assertEquals(null, multimap.get(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3), null));
                 break;
-                case 5:
+            case 5:
                 assertEquals(value, multimap.get(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3), key.getKey(4)));
                 assertEquals(null, multimap.get(null, key.getKey(1), key.getKey(2), key.getKey(3), key.getKey(4)));
                 assertEquals(null, multimap.get(key.getKey(0), null, key.getKey(2), key.getKey(3), key.getKey(4)));
@@ -183,7 +183,7 @@ public class MultiKeyMapTest<K, V> extends AbstractIterableMapTest<MultiKey<? ex
                 assertEquals(null, multimap.get(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3), null));
                 assertEquals(null, multimap.get(null, null, null, null, null));
                 break;
-                default:
+            default:
                 fail("Invalid key size");
             }
         }
@@ -196,7 +196,7 @@ public class MultiKeyMapTest<K, V> extends AbstractIterableMapTest<MultiKey<? ex
 
         for (final MultiKey<K> key : keys) {
             switch (key.size()) {
-                case 2:
+            case 2:
                 assertEquals(true, multimap.containsKey(key.getKey(0), key.getKey(1)));
                 assertEquals(false, multimap.containsKey(null, key.getKey(1)));
                 assertEquals(false, multimap.containsKey(key.getKey(0), null));
@@ -205,7 +205,7 @@ public class MultiKeyMapTest<K, V> extends AbstractIterableMapTest<MultiKey<? ex
                 assertEquals(false, multimap.containsKey(key.getKey(0), key.getKey(1), null, null));
                 assertEquals(false, multimap.containsKey(key.getKey(0), key.getKey(1), null, null, null));
                 break;
-                case 3:
+            case 3:
                 assertEquals(true, multimap.containsKey(key.getKey(0), key.getKey(1), key.getKey(2)));
                 assertEquals(false, multimap.containsKey(null, key.getKey(1), key.getKey(2)));
                 assertEquals(false, multimap.containsKey(key.getKey(0), null, key.getKey(2)));
@@ -214,7 +214,7 @@ public class MultiKeyMapTest<K, V> extends AbstractIterableMapTest<MultiKey<? ex
                 assertEquals(false, multimap.containsKey(key.getKey(0), key.getKey(1), key.getKey(2), null));
                 assertEquals(false, multimap.containsKey(key.getKey(0), key.getKey(1), key.getKey(2), null, null));
                 break;
-                case 4:
+            case 4:
                 assertEquals(true, multimap.containsKey(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3)));
                 assertEquals(false, multimap.containsKey(null, key.getKey(1), key.getKey(2), key.getKey(3)));
                 assertEquals(false, multimap.containsKey(key.getKey(0), null, key.getKey(2), key.getKey(3)));
@@ -223,7 +223,7 @@ public class MultiKeyMapTest<K, V> extends AbstractIterableMapTest<MultiKey<? ex
                 assertEquals(false, multimap.containsKey(null, null, null, null));
                 assertEquals(false, multimap.containsKey(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3), null));
                 break;
-                case 5:
+            case 5:
                 assertEquals(true, multimap.containsKey(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3), key.getKey(4)));
                 assertEquals(false, multimap.containsKey(null, key.getKey(1), key.getKey(2), key.getKey(3), key.getKey(4)));
                 assertEquals(false, multimap.containsKey(key.getKey(0), null, key.getKey(2), key.getKey(3), key.getKey(4)));
@@ -232,7 +232,7 @@ public class MultiKeyMapTest<K, V> extends AbstractIterableMapTest<MultiKey<? ex
                 assertEquals(false, multimap.containsKey(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3), null));
                 assertEquals(false, multimap.containsKey(null, null, null, null, null));
                 break;
-                default:
+            default:
                 fail("Invalid key size");
             }
         }
@@ -249,7 +249,7 @@ public class MultiKeyMapTest<K, V> extends AbstractIterableMapTest<MultiKey<? ex
             final V value = values[i];
 
             switch (key.size()) {
-                case 2:
+            case 2:
                 assertEquals(null, multimap.put(key.getKey(0), key.getKey(1), value));
                 assertEquals(1, multimap.size());
                 assertEquals(value, multimap.get(key.getKey(0), key.getKey(1)));
@@ -260,7 +260,7 @@ public class MultiKeyMapTest<K, V> extends AbstractIterableMapTest<MultiKey<? ex
                 assertEquals(null, multimap.get(key.getKey(0), key.getKey(1)));
                 assertEquals(true, multimap.containsKey(key.getKey(0), key.getKey(1)));
                 break;
-                case 3:
+            case 3:
                 assertEquals(null, multimap.put(key.getKey(0), key.getKey(1), key.getKey(2), value));
                 assertEquals(1, multimap.size());
                 assertEquals(value, multimap.get(key.getKey(0), key.getKey(1), key.getKey(2)));
@@ -271,7 +271,7 @@ public class MultiKeyMapTest<K, V> extends AbstractIterableMapTest<MultiKey<? ex
                 assertEquals(null, multimap.get(key.getKey(0), key.getKey(1), key.getKey(2)));
                 assertEquals(true, multimap.containsKey(key.getKey(0), key.getKey(1), key.getKey(2)));
                 break;
-                case 4:
+            case 4:
                 assertEquals(null, multimap.put(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3), value));
                 assertEquals(1, multimap.size());
                 assertEquals(value, multimap.get(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3)));
@@ -282,7 +282,7 @@ public class MultiKeyMapTest<K, V> extends AbstractIterableMapTest<MultiKey<? ex
                 assertEquals(null, multimap.get(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3)));
                 assertEquals(true, multimap.containsKey(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3)));
                 break;
-                case 5:
+            case 5:
                 assertEquals(null, multimap.put(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3), key.getKey(4), value));
                 assertEquals(1, multimap.size());
                 assertEquals(value, multimap.get(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3), key.getKey(4)));
@@ -293,7 +293,7 @@ public class MultiKeyMapTest<K, V> extends AbstractIterableMapTest<MultiKey<? ex
                 assertEquals(null, multimap.get(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3), key.getKey(4)));
                 assertEquals(true, multimap.containsKey(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3), key.getKey(4)));
                 break;
-                default:
+            default:
                 fail("Invalid key size");
             }
         }
@@ -328,7 +328,7 @@ public class MultiKeyMapTest<K, V> extends AbstractIterableMapTest<MultiKey<? ex
             final V value = values[i];
 
             switch (key.size()) {
-                case 2:
+            case 2:
                 assertEquals(true, multimap.containsKey(key.getKey(0), key.getKey(1)));
                 assertEquals(value, multimap.removeMultiKey(key.getKey(0), key.getKey(1)));
                 assertEquals(false, multimap.containsKey(key.getKey(0), key.getKey(1)));
@@ -336,7 +336,7 @@ public class MultiKeyMapTest<K, V> extends AbstractIterableMapTest<MultiKey<? ex
                 assertEquals(null, multimap.removeMultiKey(key.getKey(0), key.getKey(1)));
                 assertEquals(false, multimap.containsKey(key.getKey(0), key.getKey(1)));
                 break;
-                case 3:
+            case 3:
                 assertEquals(true, multimap.containsKey(key.getKey(0), key.getKey(1), key.getKey(2)));
                 assertEquals(value, multimap.removeMultiKey(key.getKey(0), key.getKey(1), key.getKey(2)));
                 assertEquals(false, multimap.containsKey(key.getKey(0), key.getKey(1), key.getKey(2)));
@@ -344,7 +344,7 @@ public class MultiKeyMapTest<K, V> extends AbstractIterableMapTest<MultiKey<? ex
                 assertEquals(null, multimap.removeMultiKey(key.getKey(0), key.getKey(1), key.getKey(2)));
                 assertEquals(false, multimap.containsKey(key.getKey(0), key.getKey(1), key.getKey(2)));
                 break;
-                case 4:
+            case 4:
                 assertEquals(true, multimap.containsKey(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3)));
                 assertEquals(value, multimap.removeMultiKey(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3)));
                 assertEquals(false, multimap.containsKey(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3)));
@@ -352,7 +352,7 @@ public class MultiKeyMapTest<K, V> extends AbstractIterableMapTest<MultiKey<? ex
                 assertEquals(null, multimap.removeMultiKey(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3)));
                 assertEquals(false, multimap.containsKey(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3)));
                 break;
-                case 5:
+            case 5:
                 assertEquals(true, multimap.containsKey(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3), key.getKey(4)));
                 assertEquals(value, multimap.removeMultiKey(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3), key.getKey(4)));
                 assertEquals(false, multimap.containsKey(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3), key.getKey(4)));
@@ -360,7 +360,7 @@ public class MultiKeyMapTest<K, V> extends AbstractIterableMapTest<MultiKey<? ex
                 assertEquals(null, multimap.removeMultiKey(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3), key.getKey(4)));
                 assertEquals(false, multimap.containsKey(key.getKey(0), key.getKey(1), key.getKey(2), key.getKey(3), key.getKey(4)));
                 break;
-                default:
+            default:
                 fail("Invalid key size");
             }
         }
diff --git a/src/test/java/org/apache/commons/collections4/map/MultiValueMapTest.java b/src/test/java/org/apache/commons/collections4/map/MultiValueMapTest.java
index 98e6673..5c4f7f6 100644
--- a/src/test/java/org/apache/commons/collections4/map/MultiValueMapTest.java
+++ b/src/test/java/org/apache/commons/collections4/map/MultiValueMapTest.java
@@ -152,8 +152,7 @@ public class MultiValueMapTest<K, V> extends AbstractObjectTest {
     public void testIterator() {
         final MultiValueMap<K, V> map = createTestMap();
         @SuppressWarnings("unchecked")
-        final
-        Collection<V> values = new ArrayList<>((Collection<V>) map.values());
+        final Collection<V> values = new ArrayList<>((Collection<V>) map.values());
         final Iterator<Map.Entry<K, V>> iterator = map.iterator();
         while (iterator.hasNext()) {
             final Map.Entry<K, V> entry = iterator.next();
diff --git a/src/test/java/org/apache/commons/collections4/map/PredicatedSortedMapTest.java b/src/test/java/org/apache/commons/collections4/map/PredicatedSortedMapTest.java
index ae50f6c..47ff456 100644
--- a/src/test/java/org/apache/commons/collections4/map/PredicatedSortedMapTest.java
+++ b/src/test/java/org/apache/commons/collections4/map/PredicatedSortedMapTest.java
@@ -172,7 +172,7 @@ public class PredicatedSortedMapTest<K, V> extends AbstractSortedMapTest<K, V> {
         assertEquals("Last key in head map should be B",
             "B", map.headMap((K) "C").lastKey());
         assertEquals("Last key in submap should be B",
-           "B", map.subMap((K) "A", (K) "C").lastKey());
+            "B", map.subMap((K) "A", (K) "C").lastKey());
 
         final Comparator<? super K> c = map.comparator();
         assertTrue("natural order, so comparator should be null",
@@ -204,7 +204,7 @@ public class PredicatedSortedMapTest<K, V> extends AbstractSortedMapTest<K, V> {
         assertEquals("Last key in head map should be B",
             "B", map.headMap((K) "A").lastKey());
         assertEquals("Last key in submap should be B",
-           "B", map.subMap((K) "C", (K) "A").lastKey());
+            "B", map.subMap((K) "C", (K) "A").lastKey());
 
         final Comparator<? super K> c = map.comparator();
         assertTrue("reverse order, so comparator should be reverseStringComparator",
diff --git a/src/test/java/org/apache/commons/collections4/map/ReferenceMapTest.java b/src/test/java/org/apache/commons/collections4/map/ReferenceMapTest.java
index a77de16..eff9bc4 100644
--- a/src/test/java/org/apache/commons/collections4/map/ReferenceMapTest.java
+++ b/src/test/java/org/apache/commons/collections4/map/ReferenceMapTest.java
@@ -312,8 +312,7 @@ public class ReferenceMapTest<K, V> extends AbstractIterableMapTest<K, V> {
         final ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
         try (ObjectInputStream in = new ObjectInputStream(bais)) {
             @SuppressWarnings("unchecked")
-            final
-            ReferenceMap<String, String> deserialisedMap = (ReferenceMap<String, String>) in.readObject();
+            final ReferenceMap<String, String> deserialisedMap = (ReferenceMap<String, String>) in.readObject();
             assertEquals(1, deserialisedMap.size());
             assertEquals(serialiseMap.data.length, deserialisedMap.data.length);
         }
diff --git a/src/test/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMapTest.java b/src/test/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMapTest.java
index 7cf764c..0d845ec 100644
--- a/src/test/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMapTest.java
+++ b/src/test/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMapTest.java
@@ -130,8 +130,8 @@ public abstract class AbstractMultiValuedMapTest<K, V> extends AbstractObjectTes
     @SuppressWarnings("unchecked")
     public K[] getSampleKeys() {
         final Object[] result = new Object[] {
-                "one", "one", "two", "two",
-                "three", "three"
+            "one", "one", "two", "two",
+            "three", "three"
         };
         return (K[]) result;
     }
@@ -145,8 +145,8 @@ public abstract class AbstractMultiValuedMapTest<K, V> extends AbstractObjectTes
     @SuppressWarnings("unchecked")
     public V[] getSampleValues() {
         final Object[] result = new Object[] {
-                "uno", "un", "dos", "deux",
-                "tres", "trois"
+            "uno", "un", "dos", "deux",
+            "tres", "trois"
         };
         return (V[]) result;
     }
@@ -217,8 +217,7 @@ public abstract class AbstractMultiValuedMapTest<K, V> extends AbstractObjectTes
     public void testMultipleValues() {
         final MultiValuedMap<K, V> map = makeFullMap();
         @SuppressWarnings("unchecked")
-        final
-        Collection<V> col = map.get((K) "one");
+        final Collection<V> col = map.get((K) "one");
         assertTrue(col.contains("uno"));
         assertTrue(col.contains("un"));
     }
@@ -287,8 +286,7 @@ public abstract class AbstractMultiValuedMapTest<K, V> extends AbstractObjectTes
         resetFull();
         final MultiValuedMap<K, V> map = getMap();
         @SuppressWarnings("unchecked")
-        final
-        Iterator<V> it = map.get((K) "one").iterator();
+        final Iterator<V> it = map.get((K) "one").iterator();
         while (it.hasNext()) {
             it.next();
             it.remove();
diff --git a/src/test/java/org/apache/commons/collections4/overview.html b/src/test/java/org/apache/commons/collections4/overview.html
index 6ae0b05..6dba0c1 100644
--- a/src/test/java/org/apache/commons/collections4/overview.html
+++ b/src/test/java/org/apache/commons/collections4/overview.html
@@ -1,18 +1,18 @@
 <!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements.  See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF licenses this file to You under the Apache License, Version 2.0
-(the "License"); you may not use this file except in compliance with
-the License.  You may obtain a copy of the License at
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
 
-     http://www.apache.org/licenses/LICENSE-2.0
+       http://www.apache.org/licenses/LICENSE-2.0
 
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
 -->
 <body>
 <p>The Collections Test Framework is an extension to JUnit to enable quick and easy testing
diff --git a/src/test/java/org/apache/commons/collections4/queue/PredicatedQueueTest.java b/src/test/java/org/apache/commons/collections4/queue/PredicatedQueueTest.java
index a78c0d8..fb50d6f 100644
--- a/src/test/java/org/apache/commons/collections4/queue/PredicatedQueueTest.java
+++ b/src/test/java/org/apache/commons/collections4/queue/PredicatedQueueTest.java
@@ -72,8 +72,7 @@ public class PredicatedQueueTest<E> extends AbstractQueueTest<E> {
 
     //------------------------------------------------------------
 
-    protected Predicate<E> testPredicate =
-            o -> o instanceof String;
+    protected Predicate<E> testPredicate = o -> o instanceof String;
 
     public Queue<E> makeTestQueue() {
         return decorateCollection(new LinkedList<E>(), testPredicate);
diff --git a/src/test/java/org/apache/commons/collections4/set/AbstractNavigableSetTest.java b/src/test/java/org/apache/commons/collections4/set/AbstractNavigableSetTest.java
index 6e46150..6a6bf2c 100644
--- a/src/test/java/org/apache/commons/collections4/set/AbstractNavigableSetTest.java
+++ b/src/test/java/org/apache/commons/collections4/set/AbstractNavigableSetTest.java
@@ -199,7 +199,7 @@ public abstract class AbstractNavigableSetTest<E> extends AbstractSortedSetTest<
                 System.arraycopy(AbstractNavigableSetTest.this.getFullElements(), 0, m_FullElements, 0, realBound);
                 m_OtherElements = (E[]) new Object[bound - 1];
                 System.arraycopy(//src src_pos dst dst_pos length
-                  AbstractNavigableSetTest.this.getOtherElements(), 0, m_OtherElements, 0, bound - 1);
+                    AbstractNavigableSetTest.this.getOtherElements(), 0, m_OtherElements, 0, bound - 1);
             } else {
                 m_Type = TYPE_TAILSET;
                 m_Inclusive = inclusive;
@@ -210,7 +210,7 @@ public abstract class AbstractNavigableSetTest<E> extends AbstractSortedSetTest<
                 System.arraycopy(allelements, realBound, m_FullElements, 0, allelements.length - realBound);
                 m_OtherElements = (E[]) new Object[allelements.length - bound - 1];
                 System.arraycopy(//src src_pos dst dst_pos length
-                  AbstractNavigableSetTest.this.getOtherElements(), bound, m_OtherElements, 0, allelements.length - bound - 1);
+                    AbstractNavigableSetTest.this.getOtherElements(), bound, m_OtherElements, 0, allelements.length - bound - 1);
             }
 
         } //type
@@ -230,7 +230,7 @@ public abstract class AbstractNavigableSetTest<E> extends AbstractSortedSetTest<
             final int otherLength = hibound - lobound;
             m_OtherElements = (E[]) new Object[otherLength - 1];
             System.arraycopy(//src src_pos dst dst_pos length
-              AbstractNavigableSetTest.this.getOtherElements(), lobound, m_OtherElements, 0, otherLength - 1);
+                AbstractNavigableSetTest.this.getOtherElements(), lobound, m_OtherElements, 0, otherLength - 1);
         }
 
         @Override
@@ -262,14 +262,14 @@ public abstract class AbstractNavigableSetTest<E> extends AbstractSortedSetTest<
         private NavigableSet<E> getSubSet(final NavigableSet<E> set) {
             final E[] elements = AbstractNavigableSetTest.this.getFullElements();
             switch (m_Type) {
-                case TYPE_SUBSET :
-                    return set.subSet(elements[m_LowBound], m_Inclusive, elements[m_HighBound], m_Inclusive);
-                case TYPE_HEADSET :
-                    return set.headSet(elements[m_HighBound], m_Inclusive);
-                case TYPE_TAILSET :
-                    return set.tailSet(elements[m_LowBound], m_Inclusive);
-                default :
-                    return null;
+            case TYPE_SUBSET :
+                return set.subSet(elements[m_LowBound], m_Inclusive, elements[m_HighBound], m_Inclusive);
+            case TYPE_HEADSET :
+                return set.headSet(elements[m_HighBound], m_Inclusive);
+            case TYPE_TAILSET :
+                return set.tailSet(elements[m_LowBound], m_Inclusive);
+            default :
+                return null;
             }
         }
 
diff --git a/src/test/java/org/apache/commons/collections4/set/AbstractSortedSetTest.java b/src/test/java/org/apache/commons/collections4/set/AbstractSortedSetTest.java
index 602f9fb..9530cb9 100644
--- a/src/test/java/org/apache/commons/collections4/set/AbstractSortedSetTest.java
+++ b/src/test/java/org/apache/commons/collections4/set/AbstractSortedSetTest.java
@@ -63,7 +63,7 @@ public abstract class AbstractSortedSetTest<E> extends AbstractSetTest<E> {
                 first = colliter.next();
                 last = first;
             } else {
-              last = colliter.next();
+                last = colliter.next();
             }
             assertEquals("Element appears to be out of order.", last, confiter.next());
         }
@@ -207,7 +207,7 @@ public abstract class AbstractSortedSetTest<E> extends AbstractSetTest<E> {
                 System.arraycopy(AbstractSortedSetTest.this.getFullElements(), 0, m_FullElements, 0, bound);
                 m_OtherElements = (E[]) new Object[bound - 1];
                 System.arraycopy(//src src_pos dst dst_pos length
-                AbstractSortedSetTest.this.getOtherElements(), 0, m_OtherElements, 0, bound - 1);
+                    AbstractSortedSetTest.this.getOtherElements(), 0, m_OtherElements, 0, bound - 1);
                 //System.out.println(new TreeSet(Arrays.asList(m_FullElements)));
                 //System.out.println(new TreeSet(Arrays.asList(m_OtherElements)));
             } else {
@@ -220,7 +220,7 @@ public abstract class AbstractSortedSetTest<E> extends AbstractSetTest<E> {
                 System.arraycopy(allelements, bound, m_FullElements, 0, allelements.length - bound);
                 m_OtherElements = (E[]) new Object[allelements.length - bound - 1];
                 System.arraycopy(//src src_pos dst dst_pos length
-                AbstractSortedSetTest.this.getOtherElements(), bound, m_OtherElements, 0, allelements.length - bound - 1);
+                    AbstractSortedSetTest.this.getOtherElements(), bound, m_OtherElements, 0, allelements.length - bound - 1);
                 //System.out.println(new TreeSet(Arrays.asList(m_FullElements)));
                 //System.out.println(new TreeSet(Arrays.asList(m_OtherElements)));
                 //resetFull();
@@ -244,7 +244,7 @@ public abstract class AbstractSortedSetTest<E> extends AbstractSetTest<E> {
             System.arraycopy(AbstractSortedSetTest.this.getFullElements(), lobound, m_FullElements, 0, length);
             m_OtherElements = (E[]) new Object[length - 1];
             System.arraycopy(//src src_pos dst dst_pos length
-            AbstractSortedSetTest.this.getOtherElements(), lobound, m_OtherElements, 0, length - 1);
+                AbstractSortedSetTest.this.getOtherElements(), lobound, m_OtherElements, 0, length - 1);
 
             //System.out.println(new TreeSet(Arrays.asList(m_FullElements)));
             //System.out.println(new TreeSet(Arrays.asList(m_OtherElements)));
@@ -280,14 +280,14 @@ public abstract class AbstractSortedSetTest<E> extends AbstractSetTest<E> {
         private SortedSet<E> getSubSet(final SortedSet<E> set) {
             final E[] elements = AbstractSortedSetTest.this.getFullElements();
             switch (m_Type) {
-                case TYPE_SUBSET :
-                    return set.subSet(elements[m_LowBound], elements[m_HighBound]);
-                case TYPE_HEADSET :
-                    return set.headSet(elements[m_HighBound]);
-                case TYPE_TAILSET :
-                    return set.tailSet(elements[m_LowBound]);
-                default :
-                    return null;
+            case TYPE_SUBSET :
+                return set.subSet(elements[m_LowBound], elements[m_HighBound]);
+            case TYPE_HEADSET :
+                return set.headSet(elements[m_HighBound]);
+            case TYPE_TAILSET :
+                return set.tailSet(elements[m_LowBound]);
+            default :
+                return null;
             }
         }
 
diff --git a/src/test/java/org/apache/commons/collections4/set/PredicatedNavigableSetTest.java b/src/test/java/org/apache/commons/collections4/set/PredicatedNavigableSetTest.java
index 74c6160..c0a1c66 100644
--- a/src/test/java/org/apache/commons/collections4/set/PredicatedNavigableSetTest.java
+++ b/src/test/java/org/apache/commons/collections4/set/PredicatedNavigableSetTest.java
@@ -83,8 +83,7 @@ public class PredicatedNavigableSetTest<E> extends AbstractNavigableSetTest<E> {
         } catch (final IllegalArgumentException e) {
             // expected
         }
-        assertTrue("Collection shouldn't contain illegal element",
-         !set.contains(testString));
+        assertTrue("Collection shouldn't contain illegal element", !set.contains(testString));
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/test/java/org/apache/commons/collections4/set/PredicatedSetTest.java b/src/test/java/org/apache/commons/collections4/set/PredicatedSetTest.java
index 5cc6544..410849f 100644
--- a/src/test/java/org/apache/commons/collections4/set/PredicatedSetTest.java
+++ b/src/test/java/org/apache/commons/collections4/set/PredicatedSetTest.java
@@ -77,8 +77,7 @@ public class PredicatedSetTest<E> extends AbstractSetTest<E> {
         } catch (final IllegalArgumentException e) {
             // expected
         }
-        assertTrue("Collection shouldn't contain illegal element",
-         !set.contains(i));
+        assertTrue("Collection shouldn't contain illegal element", !set.contains(i));
     }
 
     @SuppressWarnings("unchecked")
@@ -95,14 +94,10 @@ public class PredicatedSetTest<E> extends AbstractSetTest<E> {
         } catch (final IllegalArgumentException e) {
             // expected
         }
-        assertTrue("Set shouldn't contain illegal element",
-         !set.contains("one"));
-        assertTrue("Set shouldn't contain illegal element",
-         !set.contains("two"));
-        assertTrue("Set shouldn't contain illegal element",
-         !set.contains(Integer.valueOf(3)));
-        assertTrue("Set shouldn't contain illegal element",
-         !set.contains("four"));
+        assertTrue("Set shouldn't contain illegal element", !set.contains("one"));
+        assertTrue("Set shouldn't contain illegal element", !set.contains("two"));
+        assertTrue("Set shouldn't contain illegal element", !set.contains(Integer.valueOf(3)));
+        assertTrue("Set shouldn't contain illegal element", !set.contains("four"));
     }
 
     @Override
diff --git a/src/test/java/org/apache/commons/collections4/set/PredicatedSortedSetTest.java b/src/test/java/org/apache/commons/collections4/set/PredicatedSortedSetTest.java
index ee49031..0976035 100644
--- a/src/test/java/org/apache/commons/collections4/set/PredicatedSortedSetTest.java
+++ b/src/test/java/org/apache/commons/collections4/set/PredicatedSortedSetTest.java
@@ -83,8 +83,7 @@ public class PredicatedSortedSetTest<E> extends AbstractSortedSetTest<E> {
         } catch (final IllegalArgumentException e) {
             // expected
         }
-        assertTrue("Collection shouldn't contain illegal element",
-         !set.contains(testString));
+        assertTrue("Collection shouldn't contain illegal element", !set.contains(testString));
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/test/java/org/apache/commons/collections4/splitmap/TransformedSplitMapTest.java b/src/test/java/org/apache/commons/collections4/splitmap/TransformedSplitMapTest.java
index decee20..1097362 100644
--- a/src/test/java/org/apache/commons/collections4/splitmap/TransformedSplitMapTest.java
+++ b/src/test/java/org/apache/commons/collections4/splitmap/TransformedSplitMapTest.java
@@ -52,7 +52,7 @@ public class TransformedSplitMapTest extends BulkTest {
 
         final Integer[] k = new Integer[] { 0, 1, 2, 3, 4, 5, 6 };
         final Object[] v = new Object[] { "", new Object(), new HashMap<>(), 0, BigInteger.TEN, null,
-                new Object[0] };
+            new Object[0] };
 
         assertEquals(0, map.size());
         for (int i = 0; i < k.length; i++) {
diff --git a/src/test/java/org/apache/commons/collections4/trie/PatriciaTrieTest.java b/src/test/java/org/apache/commons/collections4/trie/PatriciaTrieTest.java
index c020d59..10a5ad9 100755
--- a/src/test/java/org/apache/commons/collections4/trie/PatriciaTrieTest.java
+++ b/src/test/java/org/apache/commons/collections4/trie/PatriciaTrieTest.java
@@ -64,11 +64,11 @@ public class PatriciaTrieTest<V> extends AbstractSortedMapTest<String, V> {
         final PatriciaTrie<String> trie = new PatriciaTrie<>();
 
         final String[] keys = new String[]{
-                "",
-                "Albert", "Xavier", "XyZ", "Anna", "Alien", "Alberto",
-                "Alberts", "Allie", "Alliese", "Alabama", "Banane",
-                "Blabla", "Amber", "Ammun", "Akka", "Akko", "Albertoo",
-                "Amma"
+            "",
+            "Albert", "Xavier", "XyZ", "Anna", "Alien", "Alberto",
+            "Alberts", "Allie", "Alliese", "Alabama", "Banane",
+            "Blabla", "Amber", "Ammun", "Akka", "Akko", "Albertoo",
+            "Amma"
         };
 
         for (final String key : keys) {
@@ -291,10 +291,10 @@ public class PatriciaTrieTest<V> extends AbstractSortedMapTest<String, V> {
         final PatriciaTrie<String> trie = new PatriciaTrie<>();
 
         final String[] keys = new String[]{
-                "Albert", "Xavier", "XyZ", "Anna", "Alien", "Alberto",
-                "Alberts", "Allie", "Alliese", "Alabama", "Banane",
-                "Blabla", "Amber", "Ammun", "Akka", "Akko", "Albertoo",
-                "Amma"
+            "Albert", "Xavier", "XyZ", "Anna", "Alien", "Alberto",
+            "Alberts", "Allie", "Alliese", "Alabama", "Banane",
+            "Blabla", "Amber", "Ammun", "Akka", "Akko", "Albertoo",
+            "Amma"
         };
 
         for (final String key : keys) {


Mime
View raw message