You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by ah...@apache.org on 2020/02/24 22:42:31 UTC
[commons-collections] 05/07: Add indentation check to checkstyle.
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....@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) {