commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From aherb...@apache.org
Subject [commons-collections] 04/07: Fixed checkstyle in tests.
Date Mon, 24 Feb 2020 22:42:30 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 9bc4d0bc614734c50f20267824b4ec13042899a4
Author: Alex Herbert <a.herbert@sussex.ac.uk>
AuthorDate: Tue Feb 18 23:25:52 2020 +0000

    Fixed checkstyle in tests.
    
    Changed rules to be more lenient on tests.
---
 pom.xml                                            |   2 +-
 src/conf/checkstyle-suppressions.xml               |   9 ++
 .../apache/commons/collections4/MapUtilsTest.java  |   2 +-
 .../commons/collections4/MultiSetUtilsTest.java    |   3 +-
 .../commons/collections4/bag/AbstractBagTest.java  |   4 +-
 .../collections4/bag/CollectionBagTest.java        |   3 +-
 .../collection/IndexedCollectionTest.java          |   2 +-
 .../comparators/AbstractComparatorTest.java        |   4 +-
 .../comparators/BooleanComparatorTest.java         |  57 +++++-----
 .../comparators/ComparatorChainTest.java           |   2 +-
 .../comparators/ReverseComparatorTest.java         |   2 +-
 .../iterators/CollatingIteratorTest.java           | 126 ++++++++++-----------
 .../collections4/iterators/FilterIteratorTest.java |   3 +-
 .../iterators/FilterListIteratorTest.java          |  10 +-
 .../collections4/iterators/IteratorChainTest.java  |  20 ++--
 .../iterators/LazyIteratorChainTest.java           |  21 ++--
 .../iterators/SingletonIteratorTest.java           |   2 +-
 .../iterators/ZippingIteratorTest.java             |  56 ++++-----
 .../collections4/list/AbstractListTest.java        |   2 +-
 .../list/CursorableLinkedListTest.java             | 124 ++++++++++----------
 .../collections4/list/FixedSizeListTest.java       |   2 +-
 .../commons/collections4/list/LazyListTest.java    |   2 +-
 .../collections4/list/PredicatedListTest.java      |   2 +-
 .../commons/collections4/map/AbstractMapTest.java  |   8 +-
 .../collections4/map/CaseInsensitiveMapTest.java   |   2 +-
 .../commons/collections4/map/HashedMapTest.java    |   2 +-
 .../commons/collections4/map/LazyMapTest.java      |  10 +-
 .../collections4/map/LazySortedMapTest.java        |  10 +-
 .../commons/collections4/map/LinkedMapTest.java    |   2 +-
 .../collections4/map/PredicatedSortedMapTest.java  |   4 +-
 .../commons/collections4/map/ReferenceMapTest.java |   2 +-
 .../collections4/map/TransformedMapTest.java       |   2 +-
 .../multimap/AbstractMultiValuedMapTest.java       |   2 +-
 .../multiset/AbstractMultiSetTest.java             |   4 +-
 .../multiset/PredicatedMultiSetTest.java           |   2 +-
 .../multiset/UnmodifiableMultiSetTest.java         |   4 +-
 .../collections4/queue/CircularFifoQueueTest.java  |   8 +-
 .../commons/collections4/set/CompositeSetTest.java |   3 +-
 38 files changed, 264 insertions(+), 261 deletions(-)

diff --git a/pom.xml b/pom.xml
index d3f89c0..cacf481 100644
--- a/pom.xml
+++ b/pom.xml
@@ -605,7 +605,7 @@
           <headerLocation>${basedir}/src/conf/license-header.txt</headerLocation>
           <suppressionsLocation>${basedir}/src/conf/checkstyle-suppressions.xml</suppressionsLocation>
           <enableRulesSummary>false</enableRulesSummary>
-          <includeTestSourceDirectory>false</includeTestSourceDirectory>
+          <includeTestSourceDirectory>true</includeTestSourceDirectory>
           <resourceExcludes>NOTICE.txt,LICENSE.txt,**/pom.properties,**/test.properties,**/resolver-status.properties</resourceExcludes>
         </configuration>
       </plugin>
diff --git a/src/conf/checkstyle-suppressions.xml b/src/conf/checkstyle-suppressions.xml
index 62f4161..030b78f 100644
--- a/src/conf/checkstyle-suppressions.xml
+++ b/src/conf/checkstyle-suppressions.xml
@@ -31,4 +31,13 @@
 
   <!-- Ignore missing javadoc param for unsupported method -->
   <suppress checks="JavadocMethod" files="FilterListIterator.java" lines="116,166" />
+
+  <!-- Be more lenient on tests. -->
+  <suppress checks="Javadoc" files=".*[/\\]test[/\\].*" />
+  <suppress checks="MultipleStringLiterals" files=".*[/\\]test[/\\].*" />
+  <suppress checks="DesignForExtension" files=".*[/\\]test[/\\].*" />
+  <suppress checks="LineLength" files=".*[/\\]test[/\\].*" />
+  <suppress checks="IllegalCatch" files=".*[/\\]test[/\\].*" />
+  <suppress checks="MethodLength" files="(MersenneTwister64|Well44497[ab]|MultiplyWithCarry256)Test" />
+  <suppress checks="AvoidStarImport" files=".*[/\\]test[/\\].*" />
 </suppressions>
diff --git a/src/test/java/org/apache/commons/collections4/MapUtilsTest.java b/src/test/java/org/apache/commons/collections4/MapUtilsTest.java
index 049ff22..7ee9897 100644
--- a/src/test/java/org/apache/commons/collections4/MapUtilsTest.java
+++ b/src/test/java/org/apache/commons/collections4/MapUtilsTest.java
@@ -942,7 +942,7 @@ public class MapUtilsTest extends AbstractAvailableLocalesTest {
         assertEquals(5.0, MapUtils.getDoubleValue(in, "noKey", (key)->{
             //sometimes the default value need to be calculated,such as System.currentTimeMillis()
             return 5.0D;
-        }),0);
+        }), 0);
 
         assertEquals(0, MapUtils.getDoubleValue(in, "noKey"), 0);
         assertEquals(2.0, MapUtils.getDouble(in, "key", 0.0), 0);
diff --git a/src/test/java/org/apache/commons/collections4/MultiSetUtilsTest.java b/src/test/java/org/apache/commons/collections4/MultiSetUtilsTest.java
index 56be2fb..85c07af 100644
--- a/src/test/java/org/apache/commons/collections4/MultiSetUtilsTest.java
+++ b/src/test/java/org/apache/commons/collections4/MultiSetUtilsTest.java
@@ -112,8 +112,7 @@ public class MultiSetUtilsTest {
         try {
             MultiSetUtils.predicatedMultiSet(multiSet, object -> object.equals("a"));
             fail("Predicate is violated for all elements not being 'a'");
-        }
-        catch (final IllegalArgumentException iae) {
+        } catch (final IllegalArgumentException iae) {
         }
     }
 }
diff --git a/src/test/java/org/apache/commons/collections4/bag/AbstractBagTest.java b/src/test/java/org/apache/commons/collections4/bag/AbstractBagTest.java
index bf682ca..e6cadd8 100644
--- a/src/test/java/org/apache/commons/collections4/bag/AbstractBagTest.java
+++ b/src/test/java/org/apache/commons/collections4/bag/AbstractBagTest.java
@@ -684,7 +684,7 @@ public abstract class AbstractBagTest<T> extends AbstractCollectionTest<T> {
         final Bag<T> bag = makeObject();
         if (bag instanceof Serializable && !skipSerializedCanonicalTests() && isTestSerialization()) {
             final Bag<?> bag2 = (Bag<?>) readExternalFormFromDisk(getCanonicalEmptyCollectionName(bag));
-            assertTrue("Bag is empty",bag2.size()  == 0);
+            assertTrue("Bag is empty", bag2.size() == 0);
             assertEquals(bag, bag2);
         }
     }
@@ -698,7 +698,7 @@ public abstract class AbstractBagTest<T> extends AbstractCollectionTest<T> {
         final Bag<T> bag = makeFullCollection();
         if (bag instanceof Serializable && !skipSerializedCanonicalTests() && isTestSerialization()) {
             final Bag<?> bag2 = (Bag<?>) readExternalFormFromDisk(getCanonicalFullCollectionName(bag));
-            assertEquals("Bag is the right size",bag.size(), bag2.size());
+            assertEquals("Bag is the right size", bag.size(), bag2.size());
             assertEquals(bag, bag2);
         }
     }
diff --git a/src/test/java/org/apache/commons/collections4/bag/CollectionBagTest.java b/src/test/java/org/apache/commons/collections4/bag/CollectionBagTest.java
index edf3d95..e1135f6 100644
--- a/src/test/java/org/apache/commons/collections4/bag/CollectionBagTest.java
+++ b/src/test/java/org/apache/commons/collections4/bag/CollectionBagTest.java
@@ -110,9 +110,8 @@ public class CollectionBagTest<T> extends AbstractCollectionTest<T> {
         final Bag<T> bag = (Bag<T>) makeFullCollection();
         if (bag instanceof Serializable && !skipSerializedCanonicalTests() && isTestSerialization()) {
             final Bag<?> bag2 = (Bag<?>) readExternalFormFromDisk(getCanonicalFullCollectionName(bag));
-            assertEquals("Bag is the right size",bag.size(), bag2.size());
+            assertEquals("Bag is the right size", bag.size(), bag2.size());
             assertEquals(bag, bag2);
         }
     }
-
 }
diff --git a/src/test/java/org/apache/commons/collections4/collection/IndexedCollectionTest.java b/src/test/java/org/apache/commons/collections4/collection/IndexedCollectionTest.java
index e78fff1..be8704b 100644
--- a/src/test/java/org/apache/commons/collections4/collection/IndexedCollectionTest.java
+++ b/src/test/java/org/apache/commons/collections4/collection/IndexedCollectionTest.java
@@ -113,7 +113,7 @@ public class IndexedCollectionTest extends AbstractCollectionTest<String> {
         coll.add("12");
         coll.add("16");
         coll.add("1");
-        coll.addAll(asList("2","3","4"));
+        coll.addAll(asList("2", "3", "4"));
 
         @SuppressWarnings("unchecked")
         final IndexedCollection<Integer, String> indexed = (IndexedCollection<Integer, String>) coll;
diff --git a/src/test/java/org/apache/commons/collections4/comparators/AbstractComparatorTest.java b/src/test/java/org/apache/commons/collections4/comparators/AbstractComparatorTest.java
index 41ce429..6309927 100644
--- a/src/test/java/org/apache/commons/collections4/comparators/AbstractComparatorTest.java
+++ b/src/test/java/org/apache/commons/collections4/comparators/AbstractComparatorTest.java
@@ -140,7 +140,7 @@ public abstract class AbstractComparatorTest<T> extends AbstractObjectTest {
 
         final List<T> randomList = getComparableObjectsOrdered();
         randomizeObjects(randomList);
-        sortObjects(randomList,comparator);
+        sortObjects(randomList, comparator);
 
         final List<T> orderedList = getComparableObjectsOrdered();
 
@@ -170,7 +170,7 @@ public abstract class AbstractComparatorTest<T> extends AbstractObjectTest {
         final StringBuilder retval = new StringBuilder();
         retval.append(TEST_DATA_PATH);
         String colName = object.getClass().getName();
-        colName = colName.substring(colName.lastIndexOf(".")+1,colName.length());
+        colName = colName.substring(colName.lastIndexOf(".") + 1, colName.length());
         retval.append(colName);
         retval.append(".version");
         retval.append(getCompatibilityVersion());
diff --git a/src/test/java/org/apache/commons/collections4/comparators/BooleanComparatorTest.java b/src/test/java/org/apache/commons/collections4/comparators/BooleanComparatorTest.java
index f6f6f02..5b5c007 100644
--- a/src/test/java/org/apache/commons/collections4/comparators/BooleanComparatorTest.java
+++ b/src/test/java/org/apache/commons/collections4/comparators/BooleanComparatorTest.java
@@ -70,30 +70,30 @@ public class BooleanComparatorTest extends AbstractComparatorTest<Boolean> {
 
     @Test
     public void testConstructors() {
-        allTests(false,new BooleanComparator());
-        allTests(false,new BooleanComparator(false));
-        allTests(true,new BooleanComparator(true));
+        allTests(false, new BooleanComparator());
+        allTests(false, new BooleanComparator(false));
+        allTests(true, new BooleanComparator(true));
     }
 
     @Test
 
     public void testStaticFactoryMethods() {
-        allTests(false,BooleanComparator.getFalseFirstComparator());
-        allTests(false,BooleanComparator.booleanComparator(false));
-        allTests(true,BooleanComparator.getTrueFirstComparator());
-        allTests(true,BooleanComparator.booleanComparator(true));
+        allTests(false, BooleanComparator.getFalseFirstComparator());
+        allTests(false, BooleanComparator.booleanComparator(false));
+        allTests(true, BooleanComparator.getTrueFirstComparator());
+        allTests(true, BooleanComparator.booleanComparator(true));
     }
 
     @Test
     public void testEqualsCompatibleInstance() {
-        assertEquals(new BooleanComparator(),new BooleanComparator(false));
-        assertEquals(new BooleanComparator(false),new BooleanComparator(false));
-        assertEquals(new BooleanComparator(false),BooleanComparator.getFalseFirstComparator());
-        assertSame(BooleanComparator.getFalseFirstComparator(),BooleanComparator.booleanComparator(false));
+        assertEquals(new BooleanComparator(), new BooleanComparator(false));
+        assertEquals(new BooleanComparator(false), new BooleanComparator(false));
+        assertEquals(new BooleanComparator(false), BooleanComparator.getFalseFirstComparator());
+        assertSame(BooleanComparator.getFalseFirstComparator(), BooleanComparator.booleanComparator(false));
 
-        assertEquals(new BooleanComparator(true),new BooleanComparator(true));
-        assertEquals(new BooleanComparator(true),BooleanComparator.getTrueFirstComparator());
-        assertSame(BooleanComparator.getTrueFirstComparator(),BooleanComparator.booleanComparator(true));
+        assertEquals(new BooleanComparator(true), new BooleanComparator(true));
+        assertEquals(new BooleanComparator(true), BooleanComparator.getTrueFirstComparator());
+        assertSame(BooleanComparator.getTrueFirstComparator(), BooleanComparator.booleanComparator(true));
 
         assertTrue(!new BooleanComparator().equals(new BooleanComparator(true)));
         assertTrue(!new BooleanComparator(true).equals(new BooleanComparator(false)));
@@ -113,16 +113,16 @@ public class BooleanComparatorTest extends AbstractComparatorTest<Boolean> {
 
     protected void trueFirstTests(final BooleanComparator comp) {
         assertNotNull(comp);
-        assertEquals(0,comp.compare(true, true));
-        assertEquals(0,comp.compare(false, false));
+        assertEquals(0, comp.compare(true, true));
+        assertEquals(0, comp.compare(false, false));
         assertTrue(comp.compare(false, true) > 0);
         assertTrue(comp.compare(true, false) < 0);
     }
 
     protected void falseFirstTests(final BooleanComparator comp) {
         assertNotNull(comp);
-        assertEquals(0,comp.compare(true, true));
-        assertEquals(0,comp.compare(false, false));
+        assertEquals(0, comp.compare(true, true));
+        assertEquals(0, comp.compare(false, false));
         assertTrue(comp.compare(false, true) < 0);
         assertTrue(comp.compare(true, false) > 0);
     }
@@ -134,35 +134,34 @@ public class BooleanComparatorTest extends AbstractComparatorTest<Boolean> {
     protected void nullArgumentTests(final BooleanComparator comp) {
         assertNotNull(comp);
         try {
-            comp.compare(null,null);
+            comp.compare(null, null);
             fail("Expected NullPointerException");
-        } catch(final NullPointerException e) {
+        } catch (final NullPointerException e) {
             // expected
         }
         try {
-            comp.compare(Boolean.TRUE,null);
+            comp.compare(Boolean.TRUE, null);
             fail("Expected NullPointerException");
-        } catch(final NullPointerException e) {
+        } catch (final NullPointerException e) {
             // expected
         }
         try {
-            comp.compare(Boolean.FALSE,null);
+            comp.compare(Boolean.FALSE, null);
             fail("Expected NullPointerException");
-        } catch(final NullPointerException e) {
+        } catch (final NullPointerException e) {
             // expected
         }
         try {
-            comp.compare(null,Boolean.TRUE);
+            comp.compare(null, Boolean.TRUE);
             fail("Expected NullPointerException");
-        } catch(final NullPointerException e) {
+        } catch (final NullPointerException e) {
             // expected
         }
         try {
-            comp.compare(null,Boolean.FALSE);
+            comp.compare(null, Boolean.FALSE);
             fail("Expected NullPointerException");
-        } catch(final NullPointerException e) {
+        } catch (final NullPointerException e) {
             // expected
         }
     }
-
 }
diff --git a/src/test/java/org/apache/commons/collections4/comparators/ComparatorChainTest.java b/src/test/java/org/apache/commons/collections4/comparators/ComparatorChainTest.java
index 1417caf..c0b4cf4 100644
--- a/src/test/java/org/apache/commons/collections4/comparators/ComparatorChainTest.java
+++ b/src/test/java/org/apache/commons/collections4/comparators/ComparatorChainTest.java
@@ -67,7 +67,7 @@ public class ComparatorChainTest extends AbstractComparatorTest<ComparatorChainT
         final Integer i1 = Integer.valueOf(4);
         final Integer i2 = Integer.valueOf(6);
         try {
-            chain.compare(i1,i2);
+            chain.compare(i1, i2);
             fail("An exception should be thrown when a chain contains zero comparators.");
         } catch (final UnsupportedOperationException e) {
         }
diff --git a/src/test/java/org/apache/commons/collections4/comparators/ReverseComparatorTest.java b/src/test/java/org/apache/commons/collections4/comparators/ReverseComparatorTest.java
index 3e5060e..c6acf13 100644
--- a/src/test/java/org/apache/commons/collections4/comparators/ReverseComparatorTest.java
+++ b/src/test/java/org/apache/commons/collections4/comparators/ReverseComparatorTest.java
@@ -90,7 +90,7 @@ public class ReverseComparatorTest extends AbstractComparatorTest<Integer> {
         final ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(buffer.toByteArray()));
         final Object dest = in.readObject();
         in.close();
-        assertEquals("obj != deserialize(serialize(obj))",comp,dest);
+        assertEquals("obj != deserialize(serialize(obj))", comp, dest);
     }
 
 }
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 1116633..06d7a5a 100644
--- a/src/test/java/org/apache/commons/collections4/iterators/CollatingIteratorTest.java
+++ b/src/test/java/org/apache/commons/collections4/iterators/CollatingIteratorTest.java
@@ -100,7 +100,7 @@ public class CollatingIteratorTest extends AbstractIteratorTest<Integer> {
         for (int i = 0; i < evens.size(); i++) {
             assertTrue(iter.hasNext());
             assertEquals(evens.get(i), iter.next());
-            assertEquals(0,iter.getIteratorIndex());
+            assertEquals(0, iter.getIteratorIndex());
         }
         assertTrue(!iter.hasNext());
     }
@@ -110,7 +110,7 @@ public class CollatingIteratorTest extends AbstractIteratorTest<Integer> {
         for (int i = 0; i < 20; i++) {
             assertTrue(iter.hasNext());
             assertEquals(Integer.valueOf(i), iter.next());
-            assertEquals(i % 2,iter.getIteratorIndex());
+            assertEquals(i % 2, iter.getIteratorIndex());
         }
         assertTrue(!iter.hasNext());
     }
@@ -119,8 +119,8 @@ public class CollatingIteratorTest extends AbstractIteratorTest<Integer> {
         final CollatingIterator<Integer> iter = new CollatingIterator<>(comparator, odds.iterator(), evens.iterator());
         for (int i = 0; i < 20; i++) {
             assertTrue(iter.hasNext());
-            assertEquals(Integer.valueOf(i),iter.next());
-            assertEquals(i % 2 == 0 ? 1 : 0,iter.getIteratorIndex());
+            assertEquals(Integer.valueOf(i), iter.next());
+            assertEquals(i % 2 == 0 ? 1 : 0, iter.getIteratorIndex());
         }
         assertTrue(!iter.hasNext());
     }
@@ -132,10 +132,10 @@ public class CollatingIteratorTest extends AbstractIteratorTest<Integer> {
         for (int i = 0; i < evens.size(); i++) {
             assertTrue(iter.hasNext());
             assertEquals(evens.get(i), iter.next());
-            assertEquals(0,iter.getIteratorIndex());
+            assertEquals(0, iter.getIteratorIndex());
             assertTrue(iter.hasNext());
             assertEquals(evens.get(i), iter.next());
-            assertEquals(1,iter.getIteratorIndex());
+            assertEquals(1, iter.getIteratorIndex());
         }
         assertTrue(!iter.hasNext());
     }
@@ -146,62 +146,62 @@ public class CollatingIteratorTest extends AbstractIteratorTest<Integer> {
         iter.addIterator(evens.iterator());
         iter.addIterator(odds.iterator());
 
-        assertEquals(Integer.valueOf(0),iter.next());  // even   0
-        assertEquals(1,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(1),iter.next());  // fib    1
-        assertEquals(0,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(1),iter.next());  // fib    1
-        assertEquals(0,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(1),iter.next());  // odd    1
-        assertEquals(2,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(2),iter.next());  // fib    2
-        assertEquals(0,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(2),iter.next());  // even   2
-        assertEquals(1,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(3),iter.next());  // fib    3
-        assertEquals(0,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(3),iter.next());  // odd    3
-        assertEquals(2,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(4),iter.next());  // even   4
-        assertEquals(1,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(5),iter.next());  // fib    5
-        assertEquals(0,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(5),iter.next());  // odd    5
-        assertEquals(2,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(6),iter.next());  // even   6
-        assertEquals(1,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(7),iter.next());  // odd    7
-        assertEquals(2,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(8),iter.next());  // fib    8
-        assertEquals(0,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(8),iter.next());  // even   8
-        assertEquals(1,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(9),iter.next());  // odd    9
-        assertEquals(2,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(10),iter.next()); // even  10
-        assertEquals(1,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(11),iter.next()); // odd   11
-        assertEquals(2,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(12),iter.next()); // even  12
-        assertEquals(1,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(13),iter.next()); // fib   13
-        assertEquals(0,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(13),iter.next()); // odd   13
-        assertEquals(2,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(14),iter.next()); // even  14
-        assertEquals(1,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(15),iter.next()); // odd   15
-        assertEquals(2,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(16),iter.next()); // even  16
-        assertEquals(1,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(17),iter.next()); // odd   17
-        assertEquals(2,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(18),iter.next()); // even  18
-        assertEquals(1,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(19),iter.next()); // odd   19
-        assertEquals(2,iter.getIteratorIndex());
-        assertEquals(Integer.valueOf(21),iter.next()); // fib   21
-        assertEquals(0,iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(0), iter.next()); // even 0
+        assertEquals(1, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(1), iter.next()); // fib 1
+        assertEquals(0, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(1), iter.next()); // fib 1
+        assertEquals(0, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(1), iter.next()); // odd 1
+        assertEquals(2, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(2), iter.next()); // fib 2
+        assertEquals(0, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(2), iter.next()); // even 2
+        assertEquals(1, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(3), iter.next()); // fib 3
+        assertEquals(0, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(3), iter.next()); // odd 3
+        assertEquals(2, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(4), iter.next()); // even 4
+        assertEquals(1, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(5), iter.next()); // fib 5
+        assertEquals(0, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(5), iter.next()); // odd 5
+        assertEquals(2, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(6), iter.next()); // even 6
+        assertEquals(1, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(7), iter.next()); // odd 7
+        assertEquals(2, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(8), iter.next()); // fib 8
+        assertEquals(0, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(8), iter.next()); // even 8
+        assertEquals(1, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(9), iter.next()); // odd 9
+        assertEquals(2, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(10), iter.next()); // even 10
+        assertEquals(1, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(11), iter.next()); // odd 11
+        assertEquals(2, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(12), iter.next()); // even 12
+        assertEquals(1, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(13), iter.next()); // fib 13
+        assertEquals(0, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(13), iter.next()); // odd 13
+        assertEquals(2, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(14), iter.next()); // even 14
+        assertEquals(1, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(15), iter.next()); // odd 15
+        assertEquals(2, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(16), iter.next()); // even 16
+        assertEquals(1, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(17), iter.next()); // odd 17
+        assertEquals(2, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(18), iter.next()); // even 18
+        assertEquals(1, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(19), iter.next()); // odd 19
+        assertEquals(2, iter.getIteratorIndex());
+        assertEquals(Integer.valueOf(21), iter.next()); // fib 21
+        assertEquals(0, iter.getIteratorIndex());
 
         assertTrue(!iter.hasNext());
     }
@@ -218,7 +218,7 @@ public class CollatingIteratorTest extends AbstractIteratorTest<Integer> {
                 iter.remove();
             }
         }
-        assertEquals(expectedSize,evens.size());
+        assertEquals(expectedSize, evens.size());
     }
 
     public void testRemoveFromDouble() {
diff --git a/src/test/java/org/apache/commons/collections4/iterators/FilterIteratorTest.java b/src/test/java/org/apache/commons/collections4/iterators/FilterIteratorTest.java
index 4154968..461f9f2 100644
--- a/src/test/java/org/apache/commons/collections4/iterators/FilterIteratorTest.java
+++ b/src/test/java/org/apache/commons/collections4/iterators/FilterIteratorTest.java
@@ -150,8 +150,7 @@ public class FilterIteratorTest<E> extends AbstractIteratorTest<E> {
         try {
             iterator.next();
             fail("NoSuchElementException expected");
-        }
-        catch (final NoSuchElementException e) {
+        } catch (final NoSuchElementException e) {
             // success
         }
     }
diff --git a/src/test/java/org/apache/commons/collections4/iterators/FilterListIteratorTest.java b/src/test/java/org/apache/commons/collections4/iterators/FilterListIteratorTest.java
index ce936d4..0507330 100644
--- a/src/test/java/org/apache/commons/collections4/iterators/FilterListIteratorTest.java
+++ b/src/test/java/org/apache/commons/collections4/iterators/FilterListIteratorTest.java
@@ -113,7 +113,7 @@ public class FilterListIteratorTest {
     @Test
     public void testWalkLists() {
         // this just confirms that our walkLists method works OK
-        walkLists(list,list.listIterator());
+        walkLists(list, list.listIterator());
     }
 
     @Test
@@ -257,8 +257,8 @@ public class FilterListIteratorTest {
         {
             final FilterListIterator<Integer> filtered = new FilterListIterator<>(list.listIterator(), threePred);
             final ListIterator<Integer> expected = threes.listIterator();
-            walkForward(expected,filtered);
-            previousPreviousNext(expected,filtered);
+            walkForward(expected, filtered);
+            previousPreviousNext(expected, filtered);
         }
         {
             final FilterListIterator<Integer> filtered = new FilterListIterator<>(list.listIterator(), truePred);
@@ -347,10 +347,10 @@ public class FilterListIteratorTest {
         final ListIterator<E> expected = list.listIterator();
 
         // walk all the way forward
-        walkForward(expected,testing);
+        walkForward(expected, testing);
 
         // walk all the way back
-        walkBackward(expected,testing);
+        walkBackward(expected, testing);
 
         // forward,back,forward
         while (expected.hasNext()) {
diff --git a/src/test/java/org/apache/commons/collections4/iterators/IteratorChainTest.java b/src/test/java/org/apache/commons/collections4/iterators/IteratorChainTest.java
index 6786b18..e3d8e32 100644
--- a/src/test/java/org/apache/commons/collections4/iterators/IteratorChainTest.java
+++ b/src/test/java/org/apache/commons/collections4/iterators/IteratorChainTest.java
@@ -134,9 +134,9 @@ public class IteratorChainTest extends AbstractIteratorTest<String> {
             }
         }
 
-        assertTrue("List is empty",list1.size() == 0);
-        assertTrue("List is empty",list2.size() == 1);
-        assertTrue("List is empty",list3.size() == 0);
+        assertTrue("List is empty", list1.size() == 0);
+        assertTrue("List is empty", list2.size() == 1);
+        assertTrue("List is empty", list3.size() == 0);
     }
 
     public void testFirstIteratorIsEmptyBug() {
@@ -148,13 +148,13 @@ public class IteratorChainTest extends AbstractIteratorTest<String> {
         final IteratorChain<String> chain = new IteratorChain<>();
         chain.addIterator(empty.iterator());
         chain.addIterator(notEmpty.iterator());
-        assertTrue("should have next",chain.hasNext());
-        assertEquals("A",chain.next());
-        assertTrue("should have next",chain.hasNext());
-        assertEquals("B",chain.next());
-        assertTrue("should have next",chain.hasNext());
-        assertEquals("C",chain.next());
-        assertTrue("should not have next",!chain.hasNext());
+        assertTrue("should have next", chain.hasNext());
+        assertEquals("A", chain.next());
+        assertTrue("should have next", chain.hasNext());
+        assertEquals("B", chain.next());
+        assertTrue("should have next", chain.hasNext());
+        assertEquals("C", chain.next());
+        assertTrue("should not have next", !chain.hasNext());
     }
 
     public void testEmptyChain() {
diff --git a/src/test/java/org/apache/commons/collections4/iterators/LazyIteratorChainTest.java b/src/test/java/org/apache/commons/collections4/iterators/LazyIteratorChainTest.java
index 1826118..3827c41 100644
--- a/src/test/java/org/apache/commons/collections4/iterators/LazyIteratorChainTest.java
+++ b/src/test/java/org/apache/commons/collections4/iterators/LazyIteratorChainTest.java
@@ -148,9 +148,9 @@ public class LazyIteratorChainTest extends AbstractIteratorTest<String> {
             }
         }
 
-        assertTrue("List is empty",list1.size() == 0);
-        assertTrue("List is empty",list2.size() == 1);
-        assertTrue("List is empty",list3.size() == 0);
+        assertTrue("List is empty", list1.size() == 0);
+        assertTrue("List is empty", list2.size() == 1);
+        assertTrue("List is empty", list3.size() == 0);
     }
 
     public void testFirstIteratorIsEmptyBug() {
@@ -171,13 +171,13 @@ public class LazyIteratorChainTest extends AbstractIteratorTest<String> {
                 return null;
             }
         };
-        assertTrue("should have next",chain.hasNext());
-        assertEquals("A",chain.next());
-        assertTrue("should have next",chain.hasNext());
-        assertEquals("B",chain.next());
-        assertTrue("should have next",chain.hasNext());
-        assertEquals("C",chain.next());
-        assertTrue("should not have next",!chain.hasNext());
+        assertTrue("should have next", chain.hasNext());
+        assertEquals("A", chain.next());
+        assertTrue("should have next", chain.hasNext());
+        assertEquals("B", chain.next());
+        assertTrue("should have next", chain.hasNext());
+        assertEquals("C", chain.next());
+        assertTrue("should not have next", !chain.hasNext());
     }
 
     public void testEmptyChain() {
@@ -192,5 +192,4 @@ public class LazyIteratorChainTest extends AbstractIteratorTest<String> {
             fail();
         } catch (final IllegalStateException ex) {}
     }
-
 }
diff --git a/src/test/java/org/apache/commons/collections4/iterators/SingletonIteratorTest.java b/src/test/java/org/apache/commons/collections4/iterators/SingletonIteratorTest.java
index 0422bd5..512708d 100644
--- a/src/test/java/org/apache/commons/collections4/iterators/SingletonIteratorTest.java
+++ b/src/test/java/org/apache/commons/collections4/iterators/SingletonIteratorTest.java
@@ -85,7 +85,7 @@ public class SingletonIteratorTest<E> extends AbstractIteratorTest<E> {
     public void testSingletonIteratorRemove() {
         final ResettableIterator<E> iter = new SingletonIterator<>((E) "xyzzy");
         assertTrue(iter.hasNext());
-        assertEquals("xyzzy",iter.next());
+        assertEquals("xyzzy", iter.next());
         iter.remove();
         iter.reset();
         assertTrue(! iter.hasNext());
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 59d3eb3..789ac13 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/AbstractListTest.java b/src/test/java/org/apache/commons/collections4/list/AbstractListTest.java
index 0954e85..d051778 100644
--- a/src/test/java/org/apache/commons/collections4/list/AbstractListTest.java
+++ b/src/test/java/org/apache/commons/collections4/list/AbstractListTest.java
@@ -1112,7 +1112,7 @@ public abstract class AbstractListTest<E> extends AbstractCollectionTest<E> {
                 // old serialized tests
                 return;
             }
-            assertEquals("List is the right size",list.size(), list2.size());
+            assertEquals("List is the right size", list.size(), list2.size());
             assertEquals(list, list2);
         }
     }
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 b7316bb..f959fb5 100644
--- a/src/test/java/org/apache/commons/collections4/list/CursorableLinkedListTest.java
+++ b/src/test/java/org/apache/commons/collections4/list/CursorableLinkedListTest.java
@@ -56,23 +56,23 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
 
     @SuppressWarnings("unchecked")
     public void testAdd() {
-        assertEquals("[]",list.toString());
+        assertEquals("[]", list.toString());
         assertTrue(list.add((E) Integer.valueOf(1)));
-        assertEquals("[1]",list.toString());
+        assertEquals("[1]", list.toString());
         assertTrue(list.add((E) Integer.valueOf(2)));
-        assertEquals("[1, 2]",list.toString());
+        assertEquals("[1, 2]", list.toString());
         assertTrue(list.add((E) Integer.valueOf(3)));
-        assertEquals("[1, 2, 3]",list.toString());
+        assertEquals("[1, 2, 3]", list.toString());
         assertTrue(list.addFirst((E) Integer.valueOf(0)));
-        assertEquals("[0, 1, 2, 3]",list.toString());
+        assertEquals("[0, 1, 2, 3]", list.toString());
         assertTrue(list.addLast((E) Integer.valueOf(4)));
-        assertEquals("[0, 1, 2, 3, 4]",list.toString());
-        list.add(0,(E) Integer.valueOf(-2));
-        assertEquals("[-2, 0, 1, 2, 3, 4]",list.toString());
-        list.add(1,(E) Integer.valueOf(-1));
-        assertEquals("[-2, -1, 0, 1, 2, 3, 4]",list.toString());
-        list.add(7,(E) Integer.valueOf(5));
-        assertEquals("[-2, -1, 0, 1, 2, 3, 4, 5]",list.toString());
+        assertEquals("[0, 1, 2, 3, 4]", list.toString());
+        list.add(0, (E) Integer.valueOf(-2));
+        assertEquals("[-2, 0, 1, 2, 3, 4]", list.toString());
+        list.add(1, (E) Integer.valueOf(-1));
+        assertEquals("[-2, -1, 0, 1, 2, 3, 4]", list.toString());
+        list.add(7, (E) Integer.valueOf(5));
+        assertEquals("[-2, -1, 0, 1, 2, 3, 4, 5]", list.toString());
 
         final List<E> list2 = new LinkedList<>();
         list2.add((E) "A");
@@ -80,34 +80,34 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
         list2.add((E) "C");
 
         assertTrue(list.addAll(list2));
-        assertEquals("[-2, -1, 0, 1, 2, 3, 4, 5, A, B, C]",list.toString());
-        assertTrue(list.addAll(3,list2));
-        assertEquals("[-2, -1, 0, A, B, C, 1, 2, 3, 4, 5, A, B, C]",list.toString());
+        assertEquals("[-2, -1, 0, 1, 2, 3, 4, 5, A, B, C]", list.toString());
+        assertTrue(list.addAll(3, list2));
+        assertEquals("[-2, -1, 0, A, B, C, 1, 2, 3, 4, 5, A, B, C]", list.toString());
     }
 
     @SuppressWarnings("unchecked")
     public void testClear() {
-        assertEquals(0,list.size());
+        assertEquals(0, list.size());
         assertTrue(list.isEmpty());
         list.clear();
-        assertEquals(0,list.size());
+        assertEquals(0, list.size());
         assertTrue(list.isEmpty());
 
         list.add((E) "element");
-        assertEquals(1,list.size());
+        assertEquals(1, list.size());
         assertTrue(!list.isEmpty());
 
         list.clear();
-        assertEquals(0,list.size());
+        assertEquals(0, list.size());
         assertTrue(list.isEmpty());
 
         list.add((E) "element1");
         list.add((E) "element2");
-        assertEquals(2,list.size());
+        assertEquals(2, list.size());
         assertTrue(!list.isEmpty());
 
         list.clear();
-        assertEquals(0,list.size());
+        assertEquals(0, list.size());
         assertTrue(list.isEmpty());
 
         for (int i = 0; i < 1000; i++) {
@@ -117,7 +117,7 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
         assertTrue(!list.isEmpty());
 
         list.clear();
-        assertEquals(0,list.size());
+        assertEquals(0, list.size());
         assertTrue(list.isEmpty());
     }
 
@@ -830,10 +830,10 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
     @SuppressWarnings("unchecked")
     public void testEqualsAndHashCode() {
         assertTrue(list.equals(list));
-        assertEquals(list.hashCode(),list.hashCode());
+        assertEquals(list.hashCode(), list.hashCode());
         list.add((E) "A");
         assertTrue(list.equals(list));
-        assertEquals(list.hashCode(),list.hashCode());
+        assertEquals(list.hashCode(), list.hashCode());
 
         final CursorableLinkedList<E> list2 = new CursorableLinkedList<>();
         assertTrue(!list.equals(list2));
@@ -844,7 +844,7 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
         assertTrue(!list3.equals(list));
         assertTrue(list2.equals(list3));
         assertTrue(list3.equals(list2));
-        assertEquals(list2.hashCode(),list3.hashCode());
+        assertEquals(list2.hashCode(), list3.hashCode());
 
         list2.add((E) "A");
         assertTrue(list.equals(list2));
@@ -855,7 +855,7 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
         list3.add((E) "A");
         assertTrue(list2.equals(list3));
         assertTrue(list3.equals(list2));
-        assertEquals(list2.hashCode(),list3.hashCode());
+        assertEquals(list2.hashCode(), list3.hashCode());
 
         list.add((E) "B");
         assertTrue(list.equals(list));
@@ -871,7 +871,7 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
         assertTrue(list2.equals(list));
         assertTrue(list2.equals(list3));
         assertTrue(list3.equals(list2));
-        assertEquals(list2.hashCode(),list3.hashCode());
+        assertEquals(list2.hashCode(), list3.hashCode());
 
         list.add((E) "C");
         list2.add((E) "C");
@@ -881,8 +881,8 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
         assertTrue(list2.equals(list));
         assertTrue(list2.equals(list3));
         assertTrue(list3.equals(list2));
-        assertEquals(list.hashCode(),list2.hashCode());
-        assertEquals(list2.hashCode(),list3.hashCode());
+        assertEquals(list.hashCode(), list2.hashCode());
+        assertEquals(list2.hashCode(), list3.hashCode());
 
         list.add((E) "D");
         list2.addFirst((E) "D");
@@ -901,10 +901,10 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
         }
 
         assertTrue(list.add((E) "A"));
-        assertEquals("A",list.get(0));
+        assertEquals("A", list.get(0));
         assertTrue(list.add((E) "B"));
-        assertEquals("A",list.get(0));
-        assertEquals("B",list.get(1));
+        assertEquals("A", list.get(0));
+        assertEquals("B", list.get(1));
 
         try {
             list.get(-1);
@@ -923,23 +923,23 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
 
     @SuppressWarnings("unchecked")
     public void testIndexOf() {
-        assertEquals(-1,list.indexOf("A"));
-        assertEquals(-1,list.lastIndexOf("A"));
+        assertEquals(-1, list.indexOf("A"));
+        assertEquals(-1, list.lastIndexOf("A"));
         list.add((E) "A");
-        assertEquals(0,list.indexOf("A"));
-        assertEquals(0,list.lastIndexOf("A"));
-        assertEquals(-1,list.indexOf("B"));
-        assertEquals(-1,list.lastIndexOf("B"));
+        assertEquals(0, list.indexOf("A"));
+        assertEquals(0, list.lastIndexOf("A"));
+        assertEquals(-1, list.indexOf("B"));
+        assertEquals(-1, list.lastIndexOf("B"));
         list.add((E) "B");
-        assertEquals(0,list.indexOf("A"));
-        assertEquals(0,list.lastIndexOf("A"));
-        assertEquals(1,list.indexOf("B"));
-        assertEquals(1,list.lastIndexOf("B"));
+        assertEquals(0, list.indexOf("A"));
+        assertEquals(0, list.lastIndexOf("A"));
+        assertEquals(1, list.indexOf("B"));
+        assertEquals(1, list.lastIndexOf("B"));
         list.addFirst((E) "B");
-        assertEquals(1,list.indexOf("A"));
-        assertEquals(1,list.lastIndexOf("A"));
-        assertEquals(0,list.indexOf("B"));
-        assertEquals(2,list.lastIndexOf("B"));
+        assertEquals(1, list.indexOf("A"));
+        assertEquals(1, list.lastIndexOf("A"));
+        assertEquals(0, list.indexOf("B"));
+        assertEquals(2, list.lastIndexOf("B"));
     }
 
     @SuppressWarnings("unchecked")
@@ -1122,32 +1122,32 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
         } catch(final IllegalStateException e) {
             // expected
         }
-        assertEquals("1",it.next());
-        assertEquals("2",it.next());
-        assertEquals("[1, 2, 3, 4, 5]",list.toString());
+        assertEquals("1", it.next());
+        assertEquals("2", it.next());
+        assertEquals("[1, 2, 3, 4, 5]", list.toString());
         it.remove();
-        assertEquals("[1, 3, 4, 5]",list.toString());
-        assertEquals("3",it.next());
-        assertEquals("3",it.previous());
-        assertEquals("1",it.previous());
+        assertEquals("[1, 3, 4, 5]", list.toString());
+        assertEquals("3", it.next());
+        assertEquals("3", it.previous());
+        assertEquals("1", it.previous());
         it.remove();
-        assertEquals("[3, 4, 5]",list.toString());
+        assertEquals("[3, 4, 5]", list.toString());
         assertTrue(!it.hasPrevious());
-        assertEquals("3",it.next());
+        assertEquals("3", it.next());
         it.remove();
-        assertEquals("[4, 5]",list.toString());
+        assertEquals("[4, 5]", list.toString());
         try {
             it.remove();
-        } catch(final IllegalStateException e) {
+        } catch (final IllegalStateException e) {
             // expected
         }
-        assertEquals("4",it.next());
-        assertEquals("5",it.next());
+        assertEquals("4", it.next());
+        assertEquals("5", it.next());
         it.remove();
-        assertEquals("[4]",list.toString());
-        assertEquals("4",it.previous());
+        assertEquals("[4]", list.toString());
+        assertEquals("4", it.previous());
         it.remove();
-        assertEquals("[]",list.toString());
+        assertEquals("[]", list.toString());
     }
 
     @Override
diff --git a/src/test/java/org/apache/commons/collections4/list/FixedSizeListTest.java b/src/test/java/org/apache/commons/collections4/list/FixedSizeListTest.java
index a3cbcd0..a4f60f9 100644
--- a/src/test/java/org/apache/commons/collections4/list/FixedSizeListTest.java
+++ b/src/test/java/org/apache/commons/collections4/list/FixedSizeListTest.java
@@ -96,7 +96,7 @@ public class FixedSizeListTest<E> extends AbstractListTest<E> {
         final FixedSizeList<String> fixedSizeList = initFixedSizeList();
 
         try {
-            fixedSizeList.add(2,"New Value");
+            fixedSizeList.add(2, "New Value");
             fail();
         } catch (final UnsupportedOperationException ex) {}
     }
diff --git a/src/test/java/org/apache/commons/collections4/list/LazyListTest.java b/src/test/java/org/apache/commons/collections4/list/LazyListTest.java
index 8765267..e6c56c9 100644
--- a/src/test/java/org/apache/commons/collections4/list/LazyListTest.java
+++ b/src/test/java/org/apache/commons/collections4/list/LazyListTest.java
@@ -106,7 +106,7 @@ public class LazyListTest extends AbstractObjectTest {
         assertFalse(list.isEmpty());
         assertNotNull(fourthElement);
         list.remove(3);
-        list.add(3,null);
+        list.add(3, null);
         fourthElement = list.get(3);
         assertNotNull(fourthElement);
     }
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 478124f..1390b2b 100644
--- a/src/test/java/org/apache/commons/collections4/list/PredicatedListTest.java
+++ b/src/test/java/org/apache/commons/collections4/list/PredicatedListTest.java
@@ -119,7 +119,7 @@ public class PredicatedListTest<E> extends AbstractListTest<E> {
         elements.add((E) "one");
         elements.add((E) "two");
         elements.add((E) "three");
-        list.addAll(1,elements);
+        list.addAll(1, elements);
         assertTrue("List should contain legal element",
          list.contains("zero"));
         assertTrue("List should contain legal element",
diff --git a/src/test/java/org/apache/commons/collections4/map/AbstractMapTest.java b/src/test/java/org/apache/commons/collections4/map/AbstractMapTest.java
index 51b9a27..a8e5813 100644
--- a/src/test/java/org/apache/commons/collections4/map/AbstractMapTest.java
+++ b/src/test/java/org/apache/commons/collections4/map/AbstractMapTest.java
@@ -338,8 +338,8 @@ public abstract class AbstractMapTest<K, V> 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"
+            "For", "then", "despite", /* of */"space", "I", "would", "be", "brought",
+            "From", "limits", "far", "remote", "where", "thou", "dost", "stay"
         };
     }
 
@@ -1437,7 +1437,7 @@ public abstract class AbstractMapTest<K, V> extends AbstractObjectTest {
         final Set<Map.Entry<K, V>> entrySet = getMap().entrySet();
         final HashSet<Map.Entry<K, V>> comparisonSet = new HashSet<>(entrySet);
         try {
-            assertFalse(entrySet.removeAll(Collections.<Map.Entry<K, V>> emptySet()));
+            assertFalse(entrySet.removeAll(Collections.<Map.Entry<K, V>>emptySet()));
         } catch (final UnsupportedOperationException e) {
             return;
         }
@@ -1478,7 +1478,7 @@ public abstract class AbstractMapTest<K, V> extends AbstractObjectTest {
         }
         assertEquals(sampleKeys.length, getMap().size());
         try {
-            assertTrue(entrySet.retainAll(Collections.<Map.Entry<K, V>> emptySet()));
+            assertTrue(entrySet.retainAll(Collections.<Map.Entry<K, V>>emptySet()));
         } catch (final UnsupportedOperationException e) {
             return;
         }
diff --git a/src/test/java/org/apache/commons/collections4/map/CaseInsensitiveMapTest.java b/src/test/java/org/apache/commons/collections4/map/CaseInsensitiveMapTest.java
index fa397b9..d80d01f 100644
--- a/src/test/java/org/apache/commons/collections4/map/CaseInsensitiveMapTest.java
+++ b/src/test/java/org/apache/commons/collections4/map/CaseInsensitiveMapTest.java
@@ -146,7 +146,7 @@ public class CaseInsensitiveMapTest<K, V> extends AbstractIterableMapTest<K, V>
      * Test for <a href="https://issues.apache.org/jira/browse/COLLECTIONS-323">COLLECTIONS-323</a>.
      */
     public void testInitialCapacityZero() {
-        final CaseInsensitiveMap<String,String> map = new CaseInsensitiveMap<>(0);
+        final CaseInsensitiveMap<String, String> map = new CaseInsensitiveMap<>(0);
         assertEquals(1, map.data.length);
     }
 }
diff --git a/src/test/java/org/apache/commons/collections4/map/HashedMapTest.java b/src/test/java/org/apache/commons/collections4/map/HashedMapTest.java
index 08852bc..f26bbbc 100644
--- a/src/test/java/org/apache/commons/collections4/map/HashedMapTest.java
+++ b/src/test/java/org/apache/commons/collections4/map/HashedMapTest.java
@@ -73,7 +73,7 @@ public class HashedMapTest<K, V> extends AbstractIterableMapTest<K, V> {
      * Test for <a href="https://issues.apache.org/jira/browse/COLLECTIONS-323">COLLECTIONS-323</a>.
      */
     public void testInitialCapacityZero() {
-        final HashedMap<String,String> map = new HashedMap<>(0);
+        final HashedMap<String, String> map = new HashedMap<>(0);
         assertEquals(1, map.data.length);
     }
 }
diff --git a/src/test/java/org/apache/commons/collections4/map/LazyMapTest.java b/src/test/java/org/apache/commons/collections4/map/LazyMapTest.java
index e73e568..30e97cd 100644
--- a/src/test/java/org/apache/commons/collections4/map/LazyMapTest.java
+++ b/src/test/java/org/apache/commons/collections4/map/LazyMapTest.java
@@ -54,26 +54,26 @@ public class LazyMapTest<K, V> extends AbstractIterableMapTest<K, V> {
 
     @Test
     public void mapGetWithFactory() {
-        Map<Integer, Number> map = lazyMap(new HashMap<Integer,Number>(), oneFactory);
+        Map<Integer, Number> map = lazyMap(new HashMap<Integer, Number>(), oneFactory);
         assertEquals(0, map.size());
         final Number i1 = map.get("Five");
         assertEquals(1, i1);
         assertEquals(1, map.size());
-        final Number i2 = map.get(new String(new char[] {'F','i','v','e'}));
+        final Number i2 = map.get(new String(new char[] {'F', 'i', 'v', 'e'}));
         assertEquals(1, i2);
         assertEquals(1, map.size());
         assertSame(i1, i2);
 
-        map = lazyMap(new HashMap<Integer,Number>(), FactoryUtils.<Long>nullFactory());
+        map = lazyMap(new HashMap<Integer, Number>(), FactoryUtils.<Long>nullFactory());
         final Object o = map.get("Five");
-        assertEquals(null,o);
+        assertEquals(null, o);
         assertEquals(1, map.size());
     }
 
     @Test
     public void mapGetWithTransformer() {
         final Transformer<Number, Integer> intConverter = input -> input.intValue();
-        final Map<Long, Number> map = lazyMap(new HashMap<Long,Number>(), intConverter );
+        final Map<Long, Number> map = lazyMap(new HashMap<Long, Number>(), intConverter);
         assertEquals(0, map.size());
         final Number i1 = map.get(123L);
         assertEquals(123, i1);
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 4bff593..2ae2377 100644
--- a/src/test/java/org/apache/commons/collections4/map/LazySortedMapTest.java
+++ b/src/test/java/org/apache/commons/collections4/map/LazySortedMapTest.java
@@ -81,14 +81,14 @@ public class LazySortedMapTest<K, V> extends AbstractSortedMapTest<K, V> {
 
         map = lazySortedMap(new TreeMap<Integer, Number>(), FactoryUtils.<Number>nullFactory());
         final Number o = map.get(5);
-        assertEquals(null,o);
+        assertEquals(null, o);
         assertEquals(1, map.size());
 
     }
 
     //-----------------------------------------------------------------------
     public void testSortOrder() {
-        final SortedMap<String, Number> map = lazySortedMap(new TreeMap<String,Number>(), oneFactory);
+        final SortedMap<String, Number> map = lazySortedMap(new TreeMap<String, Number>(), oneFactory);
         map.put("A",  5);
         map.get("B"); // Entry with value "One" created
         map.put("C", 8);
@@ -99,7 +99,7 @@ public class LazySortedMapTest<K, V> extends AbstractSortedMapTest<K, V> {
         assertEquals("Last key in head map should be B",
             "B", map.headMap("C").lastKey());
         assertEquals("Last key in submap should be B",
-            "B", map.subMap("A","C").lastKey());
+            "B", map.subMap("A", "C").lastKey());
 
         final Comparator<?> c = map.comparator();
         assertTrue("natural order, so comparator should be null",
@@ -118,7 +118,7 @@ public class LazySortedMapTest<K, V> extends AbstractSortedMapTest<K, V> {
         assertEquals("Last key in head map should be B",
             "B", map.headMap("A").lastKey());
         assertEquals("Last key in submap should be B",
-            "B", map.subMap("C","A").lastKey());
+            "B", map.subMap("C", "A").lastKey());
 
         final Comparator<?> c = map.comparator();
         assertTrue("natural order, so comparator should be null",
@@ -136,7 +136,7 @@ public class LazySortedMapTest<K, V> extends AbstractSortedMapTest<K, V> {
             // expected
         }
         try {
-            map = lazySortedMap((SortedMap<Integer,Number>) null, transformer);
+            map = lazySortedMap((SortedMap<Integer, Number>) null, transformer);
             fail("Expecting NullPointerException for null map");
         } catch (final NullPointerException e) {
             // expected
diff --git a/src/test/java/org/apache/commons/collections4/map/LinkedMapTest.java b/src/test/java/org/apache/commons/collections4/map/LinkedMapTest.java
index bb9bef9..ff423f7 100644
--- a/src/test/java/org/apache/commons/collections4/map/LinkedMapTest.java
+++ b/src/test/java/org/apache/commons/collections4/map/LinkedMapTest.java
@@ -300,7 +300,7 @@ public class LinkedMapTest<K, V> extends AbstractOrderedMapTest<K, V> {
      * Test for <a href="https://issues.apache.org/jira/browse/COLLECTIONS-323">COLLECTIONS-323</a>.
      */
     public void testInitialCapacityZero() {
-        final LinkedMap<String,String> map = new LinkedMap<>(0);
+        final LinkedMap<String, String> map = new LinkedMap<>(0);
         assertEquals(1, map.data.length);
     }
 }
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 b7e58b8..ae50f6c 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 56681e1..a77de16 100644
--- a/src/test/java/org/apache/commons/collections4/map/ReferenceMapTest.java
+++ b/src/test/java/org/apache/commons/collections4/map/ReferenceMapTest.java
@@ -313,7 +313,7 @@ public class ReferenceMapTest<K, V> extends AbstractIterableMapTest<K, V> {
         try (ObjectInputStream in = new ObjectInputStream(bais)) {
             @SuppressWarnings("unchecked")
             final
-            ReferenceMap<String, String> deserialisedMap = (ReferenceMap<String,String>) in.readObject();
+            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/map/TransformedMapTest.java b/src/test/java/org/apache/commons/collections4/map/TransformedMapTest.java
index f48c467..7468de6 100644
--- a/src/test/java/org/apache/commons/collections4/map/TransformedMapTest.java
+++ b/src/test/java/org/apache/commons/collections4/map/TransformedMapTest.java
@@ -41,7 +41,7 @@ public class TransformedMapTest<K, V> extends AbstractIterableMapTest<K, V> {
     @Override
     public IterableMap<K, V> makeObject() {
         return TransformedMap.transformingMap(new HashMap<K, V>(), TransformerUtils.<K>nopTransformer(),
-                TransformerUtils.<V> nopTransformer());
+                TransformerUtils.<V>nopTransformer());
     }
 
     //-----------------------------------------------------------------------
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 63bd897..7cf764c 100644
--- a/src/test/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMapTest.java
+++ b/src/test/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMapTest.java
@@ -62,7 +62,7 @@ public abstract class AbstractMultiValuedMapTest<K, V> extends AbstractObjectTes
     }
 
     @Override
-    abstract public MultiValuedMap<K, V> makeObject();
+    public abstract MultiValuedMap<K, V> makeObject();
 
     @Override
     public String getCompatibilityVersion() {
diff --git a/src/test/java/org/apache/commons/collections4/multiset/AbstractMultiSetTest.java b/src/test/java/org/apache/commons/collections4/multiset/AbstractMultiSetTest.java
index 5a756b4..161883f 100644
--- a/src/test/java/org/apache/commons/collections4/multiset/AbstractMultiSetTest.java
+++ b/src/test/java/org/apache/commons/collections4/multiset/AbstractMultiSetTest.java
@@ -696,7 +696,7 @@ public abstract class AbstractMultiSetTest<T> extends AbstractCollectionTest<T>
         final MultiSet<T> multiset = makeObject();
         if (multiset instanceof Serializable && !skipSerializedCanonicalTests() && isTestSerialization()) {
             final MultiSet<?> multiset2 = (MultiSet<?>) readExternalFormFromDisk(getCanonicalEmptyCollectionName(multiset));
-            assertTrue("MultiSet is empty",multiset2.size()  == 0);
+            assertTrue("MultiSet is empty", multiset2.size() == 0);
             assertEquals(multiset, multiset2);
         }
     }
@@ -710,7 +710,7 @@ public abstract class AbstractMultiSetTest<T> extends AbstractCollectionTest<T>
         final MultiSet<T> multiset = makeFullCollection();
         if (multiset instanceof Serializable && !skipSerializedCanonicalTests() && isTestSerialization()) {
             final MultiSet<?> multiset2 = (MultiSet<?>) readExternalFormFromDisk(getCanonicalFullCollectionName(multiset));
-            assertEquals("MultiSet is the right size",multiset.size(), multiset2.size());
+            assertEquals("MultiSet is the right size", multiset.size(), multiset2.size());
             assertEquals(multiset, multiset2);
         }
     }
diff --git a/src/test/java/org/apache/commons/collections4/multiset/PredicatedMultiSetTest.java b/src/test/java/org/apache/commons/collections4/multiset/PredicatedMultiSetTest.java
index 1de9be5..befa431 100644
--- a/src/test/java/org/apache/commons/collections4/multiset/PredicatedMultiSetTest.java
+++ b/src/test/java/org/apache/commons/collections4/multiset/PredicatedMultiSetTest.java
@@ -75,7 +75,7 @@ public class PredicatedMultiSetTest<T> extends AbstractMultiSetTest<T> {
             assertEquals(true, multiset.contains(els[i]));
         }
         Set<T> set = ((PredicatedMultiSet<T>) multiset).uniqueSet();
-        assertTrue("Unique set contains the first element",set.contains(els[0]));
+        assertTrue("Unique set contains the first element", set.contains(els[0]));
         assertEquals(true, multiset.remove(els[0]));
         set = ((PredicatedMultiSet<T>) multiset).uniqueSet();
         assertTrue("Unique set does not contain anymore the first element",
diff --git a/src/test/java/org/apache/commons/collections4/multiset/UnmodifiableMultiSetTest.java b/src/test/java/org/apache/commons/collections4/multiset/UnmodifiableMultiSetTest.java
index a5efdf1..ff2166b 100644
--- a/src/test/java/org/apache/commons/collections4/multiset/UnmodifiableMultiSetTest.java
+++ b/src/test/java/org/apache/commons/collections4/multiset/UnmodifiableMultiSetTest.java
@@ -96,7 +96,7 @@ public class UnmodifiableMultiSetTest<E> extends AbstractMultiSetTest<E> {
         final MultiSet<E> multiset = makeFullCollection();
         final MultiSet<E> unmodifiableMultiSet =  UnmodifiableMultiSet.unmodifiableMultiSet(multiset);
         try {
-            unmodifiableMultiSet.add((E) "One",1);
+            unmodifiableMultiSet.add((E) "One", 1);
             fail();
         } catch (final UnsupportedOperationException ex) {}
     }
@@ -114,7 +114,7 @@ public class UnmodifiableMultiSetTest<E> extends AbstractMultiSetTest<E> {
         final MultiSet<E> multiset = makeFullCollection();
         final MultiSet<E> unmodifiableMultiSet =  UnmodifiableMultiSet.unmodifiableMultiSet(multiset);
         try {
-            unmodifiableMultiSet.setCount((E) "One",2);
+            unmodifiableMultiSet.setCount((E) "One", 2);
             fail();
         } catch (final UnsupportedOperationException ex) {}
     }
diff --git a/src/test/java/org/apache/commons/collections4/queue/CircularFifoQueueTest.java b/src/test/java/org/apache/commons/collections4/queue/CircularFifoQueueTest.java
index 108bcd0..ac9796e 100644
--- a/src/test/java/org/apache/commons/collections4/queue/CircularFifoQueueTest.java
+++ b/src/test/java/org/apache/commons/collections4/queue/CircularFifoQueueTest.java
@@ -435,13 +435,13 @@ public class CircularFifoQueueTest<E> extends AbstractQueueTest<E> {
 
     public void testDefaultSizeAndGetError1() {
         final CircularFifoQueue<E> fifo = new CircularFifoQueue<>();
-        assertEquals(32,fifo.maxSize());
+        assertEquals(32, fifo.maxSize());
         fifo.add((E) "1");
         fifo.add((E) "2");
         fifo.add((E) "3");
         fifo.add((E) "4");
         fifo.add((E) "5");
-        assertEquals(5,fifo.size());
+        assertEquals(5, fifo.size());
         try {
             fifo.get(5);
         } catch (final NoSuchElementException ex) {
@@ -452,13 +452,13 @@ public class CircularFifoQueueTest<E> extends AbstractQueueTest<E> {
 
     public void testDefaultSizeAndGetError2() {
         final CircularFifoQueue<E> fifo = new CircularFifoQueue<>();
-        assertEquals(32,fifo.maxSize());
+        assertEquals(32, fifo.maxSize());
         fifo.add((E) "1");
         fifo.add((E) "2");
         fifo.add((E) "3");
         fifo.add((E) "4");
         fifo.add((E) "5");
-        assertEquals(5,fifo.size());
+        assertEquals(5, fifo.size());
         try {
             fifo.get(-2);
         } catch (final NoSuchElementException ex) {
diff --git a/src/test/java/org/apache/commons/collections4/set/CompositeSetTest.java b/src/test/java/org/apache/commons/collections4/set/CompositeSetTest.java
index 1d38694..5b0e21d 100644
--- a/src/test/java/org/apache/commons/collections4/set/CompositeSetTest.java
+++ b/src/test/java/org/apache/commons/collections4/set/CompositeSetTest.java
@@ -132,8 +132,7 @@ public class CompositeSetTest<E> extends AbstractSetTest<E> {
         try {
             set.addComposited(three);
             fail("IllegalArgumentException should have been thrown");
-        }
-        catch (final IllegalArgumentException e) {
+        } catch (final IllegalArgumentException e) {
             // expected
         }
     }


Mime
View raw message