You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by ki...@apache.org on 2020/04/19 06:40:41 UTC
[commons-collections] branch master updated: Simplify several
assertions in CollectionUtilsTest.
This is an automated email from the ASF dual-hosted git repository.
kinow pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-collections.git
The following commit(s) were added to refs/heads/master by this push:
new e22691f Simplify several assertions in CollectionUtilsTest.
new 477db84 Merge branch 'pr-158'
e22691f is described below
commit e22691f8108abd2a7a45f6ac3fd61b3e2d0affc3
Author: Isira Seneviratne <is...@gmail.com>
AuthorDate: Sun Apr 19 07:29:15 2020 +0530
Simplify several assertions in CollectionUtilsTest.
Also remove use of Integer constructor as it has been deprecated since Java 9.
---
.../commons/collections4/CollectionUtilsTest.java | 231 ++++++-----
.../commons/collections4/ComparatorUtilsTest.java | 14 +-
.../commons/collections4/FactoryUtilsTest.java | 9 +-
.../commons/collections4/IterableUtilsTest.java | 10 +-
.../commons/collections4/MultiMapUtilsTest.java | 30 +-
.../commons/collections4/PredicateUtilsTest.java | 279 +++++++-------
.../apache/commons/collections4/SetUtilsTest.java | 28 +-
.../commons/collections4/TransformerUtilsTest.java | 61 +--
.../commons/collections4/bag/AbstractBagTest.java | 107 +++---
.../collections4/bag/CollectionBagTest.java | 2 +-
.../collections4/bag/CollectionSortedBagTest.java | 2 +-
.../collections4/bag/PredicatedBagTest.java | 18 +-
.../collections4/bag/PredicatedSortedBagTest.java | 2 +-
.../collections4/bag/TransformedBagTest.java | 18 +-
.../collections4/bag/TransformedSortedBagTest.java | 8 +-
.../collections4/bidimap/AbstractBidiMapTest.java | 74 ++--
.../bidimap/AbstractSortedBidiMapTest.java | 424 ++++++++++-----------
.../collection/AbstractCollectionTest.java | 72 ++--
.../collection/CompositeCollectionTest.java | 35 +-
.../collection/PredicatedCollectionTest.java | 20 +-
.../collection/TransformedCollectionTest.java | 21 +-
.../comparators/AbstractComparatorTest.java | 15 +-
.../comparators/BooleanComparatorTest.java | 17 +-
.../comparators/ComparatorChainTest.java | 81 ++--
.../comparators/FixedOrderComparatorTest.java | 13 +-
.../functors/AbstractPredicateTest.java | 4 +-
.../functors/ComparatorPredicateTest.java | 30 +-
.../collections4/functors/EqualPredicateTest.java | 6 +-
.../collections4/functors/NullPredicateTest.java | 4 +-
29 files changed, 760 insertions(+), 875 deletions(-)
diff --git a/src/test/java/org/apache/commons/collections4/CollectionUtilsTest.java b/src/test/java/org/apache/commons/collections4/CollectionUtilsTest.java
index 3f69ebc..ed84795 100644
--- a/src/test/java/org/apache/commons/collections4/CollectionUtilsTest.java
+++ b/src/test/java/org/apache/commons/collections4/CollectionUtilsTest.java
@@ -19,6 +19,7 @@ package org.apache.commons.collections4;
import static org.apache.commons.collections4.functors.EqualPredicate.equalPredicate;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
@@ -304,19 +305,19 @@ public class CollectionUtilsTest extends MockTestCase {
multiples.add("3");
multiples.add("1");
- assertTrue("containsAll({1},{1,3}) should return false.", !CollectionUtils.containsAll(one, odds));
+ assertFalse("containsAll({1},{1,3}) should return false.", CollectionUtils.containsAll(one, odds));
assertTrue("containsAll({1,3},{1}) should return true.", CollectionUtils.containsAll(odds, one));
- assertTrue("containsAll({3},{1,3}) should return false.", !CollectionUtils.containsAll(three, odds));
+ assertFalse("containsAll({3},{1,3}) should return false.", CollectionUtils.containsAll(three, odds));
assertTrue("containsAll({1,3},{3}) should return true.", CollectionUtils.containsAll(odds, three));
assertTrue("containsAll({2},{2}) should return true.", CollectionUtils.containsAll(two, two));
assertTrue("containsAll({1,3},{1,3}) should return true.", CollectionUtils.containsAll(odds, odds));
- assertTrue("containsAll({2},{1,3}) should return false.", !CollectionUtils.containsAll(two, odds));
- assertTrue("containsAll({1,3},{2}) should return false.", !CollectionUtils.containsAll(odds, two));
- assertTrue("containsAll({1},{3}) should return false.", !CollectionUtils.containsAll(one, three));
- assertTrue("containsAll({3},{1}) should return false.", !CollectionUtils.containsAll(three, one));
+ assertFalse("containsAll({2},{1,3}) should return false.", CollectionUtils.containsAll(two, odds));
+ assertFalse("containsAll({1,3},{2}) should return false.", CollectionUtils.containsAll(odds, two));
+ assertFalse("containsAll({1},{3}) should return false.", CollectionUtils.containsAll(one, three));
+ assertFalse("containsAll({3},{1}) should return false.", CollectionUtils.containsAll(three, one));
assertTrue("containsAll({1,3},{}) should return true.", CollectionUtils.containsAll(odds, empty));
- assertTrue("containsAll({},{1,3}) should return false.", !CollectionUtils.containsAll(empty, odds));
+ assertFalse("containsAll({},{1,3}) should return false.", CollectionUtils.containsAll(empty, odds));
assertTrue("containsAll({},{}) should return true.", CollectionUtils.containsAll(empty, empty));
assertTrue("containsAll({1,3},{1,3,1}) should return true.", CollectionUtils.containsAll(odds, multiples));
@@ -343,13 +344,13 @@ public class CollectionUtilsTest extends MockTestCase {
assertTrue("containsAny({2},{2}) should return true.", CollectionUtils.containsAny(two, two));
assertTrue("containsAny({1,3},{1,3}) should return true.", CollectionUtils.containsAny(odds, odds));
- assertTrue("containsAny({2},{1,3}) should return false.", !CollectionUtils.containsAny(two, odds));
- assertTrue("containsAny({1,3},{2}) should return false.", !CollectionUtils.containsAny(odds, two));
- assertTrue("containsAny({1},{3}) should return false.", !CollectionUtils.containsAny(one, three));
- assertTrue("containsAny({3},{1}) should return false.", !CollectionUtils.containsAny(three, one));
- assertTrue("containsAny({1,3},{}) should return false.", !CollectionUtils.containsAny(odds, empty));
- assertTrue("containsAny({},{1,3}) should return false.", !CollectionUtils.containsAny(empty, odds));
- assertTrue("containsAny({},{}) should return false.", !CollectionUtils.containsAny(empty, empty));
+ assertFalse("containsAny({2},{1,3}) should return false.", CollectionUtils.containsAny(two, odds));
+ assertFalse("containsAny({1,3},{2}) should return false.", CollectionUtils.containsAny(odds, two));
+ assertFalse("containsAny({1},{3}) should return false.", CollectionUtils.containsAny(one, three));
+ assertFalse("containsAny({3},{1}) should return false.", CollectionUtils.containsAny(three, one));
+ assertFalse("containsAny({1,3},{}) should return false.", CollectionUtils.containsAny(odds, empty));
+ assertFalse("containsAny({},{1,3}) should return false.", CollectionUtils.containsAny(empty, odds));
+ assertFalse("containsAny({},{}) should return false.", CollectionUtils.containsAny(empty, empty));
}
@Test(expected = NullPointerException.class)
@@ -400,13 +401,13 @@ public class CollectionUtilsTest extends MockTestCase {
assertTrue("containsAny({2},{2}) should return true.", CollectionUtils.containsAny(two, twoArr));
assertTrue("containsAny({1,3},{1,3}) should return true.", CollectionUtils.containsAny(odds, oddsArr));
- assertTrue("containsAny({2},{1,3}) should return false.", !CollectionUtils.containsAny(two, oddsArr));
- assertTrue("containsAny({1,3},{2}) should return false.", !CollectionUtils.containsAny(odds, twoArr));
- assertTrue("containsAny({1},{3}) should return false.", !CollectionUtils.containsAny(one, threeArr));
- assertTrue("containsAny({3},{1}) should return false.", !CollectionUtils.containsAny(three, oneArr));
- assertTrue("containsAny({1,3},{}) should return false.", !CollectionUtils.containsAny(odds, emptyArr));
- assertTrue("containsAny({},{1,3}) should return false.", !CollectionUtils.containsAny(empty, oddsArr));
- assertTrue("containsAny({},{}) should return false.", !CollectionUtils.containsAny(empty, emptyArr));
+ assertFalse("containsAny({2},{1,3}) should return false.", CollectionUtils.containsAny(two, oddsArr));
+ assertFalse("containsAny({1,3},{2}) should return false.", CollectionUtils.containsAny(odds, twoArr));
+ assertFalse("containsAny({1},{3}) should return false.", CollectionUtils.containsAny(one, threeArr));
+ assertFalse("containsAny({3},{1}) should return false.", CollectionUtils.containsAny(three, oneArr));
+ assertFalse("containsAny({1,3},{}) should return false.", CollectionUtils.containsAny(odds, emptyArr));
+ assertFalse("containsAny({},{1,3}) should return false.", CollectionUtils.containsAny(empty, oddsArr));
+ assertFalse("containsAny({},{}) should return false.", CollectionUtils.containsAny(empty, emptyArr));
}
@Test(expected = NullPointerException.class)
@@ -601,47 +602,47 @@ public class CollectionUtilsTest extends MockTestCase {
@Test
public void testIsSubCollection() {
- assertTrue(!CollectionUtils.isSubCollection(collectionA, collectionC));
- assertTrue(!CollectionUtils.isSubCollection(collectionC, collectionA));
+ assertFalse(CollectionUtils.isSubCollection(collectionA, collectionC));
+ assertFalse(CollectionUtils.isSubCollection(collectionC, collectionA));
}
@Test
public void testIsSubCollection2() {
final Collection<Integer> c = new ArrayList<>();
assertTrue(CollectionUtils.isSubCollection(c, collectionA));
- assertTrue(!CollectionUtils.isSubCollection(collectionA, c));
+ assertFalse(CollectionUtils.isSubCollection(collectionA, c));
c.add(1);
assertTrue(CollectionUtils.isSubCollection(c, collectionA));
- assertTrue(!CollectionUtils.isSubCollection(collectionA, c));
+ assertFalse(CollectionUtils.isSubCollection(collectionA, c));
c.add(2);
assertTrue(CollectionUtils.isSubCollection(c, collectionA));
- assertTrue(!CollectionUtils.isSubCollection(collectionA, c));
+ assertFalse(CollectionUtils.isSubCollection(collectionA, c));
c.add(2);
assertTrue(CollectionUtils.isSubCollection(c, collectionA));
- assertTrue(!CollectionUtils.isSubCollection(collectionA, c));
+ assertFalse(CollectionUtils.isSubCollection(collectionA, c));
c.add(3);
assertTrue(CollectionUtils.isSubCollection(c, collectionA));
- assertTrue(!CollectionUtils.isSubCollection(collectionA, c));
+ assertFalse(CollectionUtils.isSubCollection(collectionA, c));
c.add(3);
assertTrue(CollectionUtils.isSubCollection(c, collectionA));
- assertTrue(!CollectionUtils.isSubCollection(collectionA, c));
+ assertFalse(CollectionUtils.isSubCollection(collectionA, c));
c.add(3);
assertTrue(CollectionUtils.isSubCollection(c, collectionA));
- assertTrue(!CollectionUtils.isSubCollection(collectionA, c));
+ assertFalse(CollectionUtils.isSubCollection(collectionA, c));
c.add(4);
assertTrue(CollectionUtils.isSubCollection(c, collectionA));
- assertTrue(!CollectionUtils.isSubCollection(collectionA, c));
+ assertFalse(CollectionUtils.isSubCollection(collectionA, c));
c.add(4);
assertTrue(CollectionUtils.isSubCollection(c, collectionA));
- assertTrue(!CollectionUtils.isSubCollection(collectionA, c));
+ assertFalse(CollectionUtils.isSubCollection(collectionA, c));
c.add(4);
assertTrue(CollectionUtils.isSubCollection(c, collectionA));
- assertTrue(!CollectionUtils.isSubCollection(collectionA, c));
+ assertFalse(CollectionUtils.isSubCollection(collectionA, c));
c.add(4);
assertTrue(CollectionUtils.isSubCollection(c, collectionA));
assertTrue(CollectionUtils.isSubCollection(collectionA, c));
c.add(5);
- assertTrue(!CollectionUtils.isSubCollection(c, collectionA));
+ assertFalse(CollectionUtils.isSubCollection(c, collectionA));
assertTrue(CollectionUtils.isSubCollection(collectionA, c));
}
@@ -667,8 +668,8 @@ public class CollectionUtilsTest extends MockTestCase {
@Test
public void testIsEqualCollection() {
- assertTrue(!CollectionUtils.isEqualCollection(collectionA, collectionC));
- assertTrue(!CollectionUtils.isEqualCollection(collectionC, collectionA));
+ assertFalse(CollectionUtils.isEqualCollection(collectionA, collectionC));
+ assertFalse(CollectionUtils.isEqualCollection(collectionC, collectionA));
}
@Test
@@ -688,20 +689,20 @@ public class CollectionUtilsTest extends MockTestCase {
assertTrue(CollectionUtils.isEqualCollection(a, b));
assertTrue(CollectionUtils.isEqualCollection(b, a));
a.add("1");
- assertTrue(!CollectionUtils.isEqualCollection(a, b));
- assertTrue(!CollectionUtils.isEqualCollection(b, a));
+ assertFalse(CollectionUtils.isEqualCollection(a, b));
+ assertFalse(CollectionUtils.isEqualCollection(b, a));
b.add("1");
assertTrue(CollectionUtils.isEqualCollection(a, b));
assertTrue(CollectionUtils.isEqualCollection(b, a));
a.add("2");
- assertTrue(!CollectionUtils.isEqualCollection(a, b));
- assertTrue(!CollectionUtils.isEqualCollection(b, a));
+ assertFalse(CollectionUtils.isEqualCollection(a, b));
+ assertFalse(CollectionUtils.isEqualCollection(b, a));
b.add("2");
assertTrue(CollectionUtils.isEqualCollection(a, b));
assertTrue(CollectionUtils.isEqualCollection(b, a));
a.add("1");
- assertTrue(!CollectionUtils.isEqualCollection(a, b));
- assertTrue(!CollectionUtils.isEqualCollection(b, a));
+ assertFalse(CollectionUtils.isEqualCollection(a, b));
+ assertFalse(CollectionUtils.isEqualCollection(b, a));
b.add("1");
assertTrue(CollectionUtils.isEqualCollection(a, b));
assertTrue(CollectionUtils.isEqualCollection(b, a));
@@ -791,22 +792,22 @@ public class CollectionUtilsTest extends MockTestCase {
public void testIsProperSubCollection() {
final Collection<String> a = new ArrayList<>();
final Collection<String> b = new ArrayList<>();
- assertTrue(!CollectionUtils.isProperSubCollection(a, b));
+ assertFalse(CollectionUtils.isProperSubCollection(a, b));
b.add("1");
assertTrue(CollectionUtils.isProperSubCollection(a, b));
- assertTrue(!CollectionUtils.isProperSubCollection(b, a));
- assertTrue(!CollectionUtils.isProperSubCollection(b, b));
- assertTrue(!CollectionUtils.isProperSubCollection(a, a));
+ assertFalse(CollectionUtils.isProperSubCollection(b, a));
+ assertFalse(CollectionUtils.isProperSubCollection(b, b));
+ assertFalse(CollectionUtils.isProperSubCollection(a, a));
a.add("1");
a.add("2");
b.add("2");
- assertTrue(!CollectionUtils.isProperSubCollection(b, a));
- assertTrue(!CollectionUtils.isProperSubCollection(a, b));
+ assertFalse(CollectionUtils.isProperSubCollection(b, a));
+ assertFalse(CollectionUtils.isProperSubCollection(a, b));
a.add("1");
assertTrue(CollectionUtils.isProperSubCollection(b, a));
assertTrue(CollectionUtils.isProperSubCollection(CollectionUtils.intersection(collectionA, collectionC), collectionA));
assertTrue(CollectionUtils.isProperSubCollection(CollectionUtils.subtract(a, b), a));
- assertTrue(!CollectionUtils.isProperSubCollection(a, CollectionUtils.subtract(a, b)));
+ assertFalse(CollectionUtils.isProperSubCollection(a, CollectionUtils.subtract(a, b)));
}
@Test(expected = NullPointerException.class)
@@ -828,10 +829,10 @@ public class CollectionUtilsTest extends MockTestCase {
public void find() {
Predicate<Number> testPredicate = equalPredicate((Number) 4);
Integer test = CollectionUtils.find(collectionA, testPredicate);
- assertTrue(test.equals(4));
+ assertEquals(4, (int) test);
testPredicate = equalPredicate((Number) 45);
test = CollectionUtils.find(collectionA, testPredicate);
- assertTrue(test == null);
+ assertNull(test);
assertNull(CollectionUtils.find(null, testPredicate));
assertNull(CollectionUtils.find(collectionA, null));
}
@@ -900,7 +901,7 @@ public class CollectionUtilsTest extends MockTestCase {
col.add(collectionB);
lastElement = CollectionUtils.forAllButLastDo(col, testClosure);
assertSame(lastElement, collectionB);
- assertTrue(!collectionB.isEmpty() );
+ assertFalse(collectionB.isEmpty());
col.clear();
lastElement = CollectionUtils.forAllButLastDo(col, testClosure);
@@ -1008,7 +1009,7 @@ public class CollectionUtilsTest extends MockTestCase {
} catch (final IndexOutOfBoundsException e) {
// expected
}
- assertTrue(!iterator.hasNext());
+ assertFalse(iterator.hasNext());
}
@Test
@@ -1030,7 +1031,7 @@ public class CollectionUtilsTest extends MockTestCase {
} catch (final IndexOutOfBoundsException e) {
// expected
}
- assertTrue(!en.hasMoreElements());
+ assertFalse(en.hasMoreElements());
}
@Test(expected = IndexOutOfBoundsException.class)
@@ -1157,15 +1158,15 @@ public class CollectionUtilsTest extends MockTestCase {
// -----------------------------------------------------------------------
@Test
public void testSizeIsEmpty_Null() {
- assertEquals(true, CollectionUtils.sizeIsEmpty(null));
+ assertTrue(CollectionUtils.sizeIsEmpty(null));
}
@Test
public void testSizeIsEmpty_List() {
final List<String> list = new ArrayList<>();
- assertEquals(true, CollectionUtils.sizeIsEmpty(list));
+ assertTrue(CollectionUtils.sizeIsEmpty(list));
list.add("a");
- assertEquals(false, CollectionUtils.sizeIsEmpty(list));
+ assertFalse(CollectionUtils.sizeIsEmpty(list));
}
@Test
@@ -1179,49 +1180,49 @@ public class CollectionUtilsTest extends MockTestCase {
@Test
public void testSizeIsEmpty_Array() {
final Object[] objectArray = new Object[0];
- assertEquals(true, CollectionUtils.sizeIsEmpty(objectArray));
+ assertTrue(CollectionUtils.sizeIsEmpty(objectArray));
final String[] stringArray = new String[3];
- assertEquals(false, CollectionUtils.sizeIsEmpty(stringArray));
+ assertFalse(CollectionUtils.sizeIsEmpty(stringArray));
stringArray[0] = "a";
stringArray[1] = "b";
stringArray[2] = "c";
- assertEquals(false, CollectionUtils.sizeIsEmpty(stringArray));
+ assertFalse(CollectionUtils.sizeIsEmpty(stringArray));
}
@Test
public void testSizeIsEmpty_PrimitiveArray() {
final int[] intArray = new int[0];
- assertEquals(true, CollectionUtils.sizeIsEmpty(intArray));
+ assertTrue(CollectionUtils.sizeIsEmpty(intArray));
final double[] doubleArray = new double[3];
- assertEquals(false, CollectionUtils.sizeIsEmpty(doubleArray));
+ assertFalse(CollectionUtils.sizeIsEmpty(doubleArray));
doubleArray[0] = 0.0d;
doubleArray[1] = 1.0d;
doubleArray[2] = 2.5d;
- assertEquals(false, CollectionUtils.sizeIsEmpty(doubleArray));
+ assertFalse(CollectionUtils.sizeIsEmpty(doubleArray));
}
@Test
public void testSizeIsEmpty_Enumeration() {
final Vector<String> list = new Vector<>();
- assertEquals(true, CollectionUtils.sizeIsEmpty(list.elements()));
+ assertTrue(CollectionUtils.sizeIsEmpty(list.elements()));
list.add("a");
- assertEquals(false, CollectionUtils.sizeIsEmpty(list.elements()));
+ assertFalse(CollectionUtils.sizeIsEmpty(list.elements()));
final Enumeration<String> en = list.elements();
en.nextElement();
- assertEquals(true, CollectionUtils.sizeIsEmpty(en));
+ assertTrue(CollectionUtils.sizeIsEmpty(en));
}
@Test
public void testSizeIsEmpty_Iterator() {
final List<String> list = new ArrayList<>();
- assertEquals(true, CollectionUtils.sizeIsEmpty(list.iterator()));
+ assertTrue(CollectionUtils.sizeIsEmpty(list.iterator()));
list.add("a");
- assertEquals(false, CollectionUtils.sizeIsEmpty(list.iterator()));
+ assertFalse(CollectionUtils.sizeIsEmpty(list.iterator()));
final Iterator<String> it = list.iterator();
it.next();
- assertEquals(true, CollectionUtils.sizeIsEmpty(it));
+ assertTrue(CollectionUtils.sizeIsEmpty(it));
}
@Test
@@ -1236,40 +1237,32 @@ public class CollectionUtilsTest extends MockTestCase {
// -----------------------------------------------------------------------
@Test
public void testIsEmptyWithEmptyCollection() {
- final Collection<Object> coll = new ArrayList<>();
- assertEquals(true, CollectionUtils.isEmpty(coll));
+ assertTrue(CollectionUtils.isEmpty(new ArrayList<>()));
}
@Test
public void testIsEmptyWithNonEmptyCollection() {
- final Collection<String> coll = new ArrayList<>();
- coll.add("item");
- assertEquals(false, CollectionUtils.isEmpty(coll));
+ assertFalse(CollectionUtils.isEmpty(Collections.singletonList("item")));
}
@Test
public void testIsEmptyWithNull() {
- final Collection<?> coll = null;
- assertEquals(true, CollectionUtils.isEmpty(coll));
+ assertTrue(CollectionUtils.isEmpty(null));
}
@Test
public void testIsNotEmptyWithEmptyCollection() {
- final Collection<Object> coll = new ArrayList<>();
- assertEquals(false, CollectionUtils.isNotEmpty(coll));
+ assertFalse(CollectionUtils.isNotEmpty(new ArrayList<>()));
}
@Test
public void testIsNotEmptyWithNonEmptyCollection() {
- final Collection<String> coll = new ArrayList<>();
- coll.add("item");
- assertEquals(true, CollectionUtils.isNotEmpty(coll));
+ assertTrue(CollectionUtils.isNotEmpty(Collections.singletonList("item")));
}
@Test
public void testIsNotEmptyWithNull() {
- final Collection<?> coll = null;
- assertEquals(false, CollectionUtils.isNotEmpty(coll));
+ assertFalse(CollectionUtils.isNotEmpty(null));
}
// -----------------------------------------------------------------------
@@ -1349,7 +1342,7 @@ public class CollectionUtilsTest extends MockTestCase {
assertFalse(CollectionUtils.exists(list, EQUALS_TWO));
list.add(2);
- assertEquals(true, CollectionUtils.exists(list, EQUALS_TWO));
+ assertTrue(CollectionUtils.exists(list, EQUALS_TWO));
}
@Test
@@ -1504,9 +1497,9 @@ public class CollectionUtilsTest extends MockTestCase {
assertEquals(3, set.size());
assertFalse(CollectionUtils.addIgnoreNull(set, "1"));
assertEquals(3, set.size());
- assertEquals(true, CollectionUtils.addIgnoreNull(set, "4"));
+ assertTrue(CollectionUtils.addIgnoreNull(set, "4"));
assertEquals(4, set.size());
- assertEquals(true, set.contains("4"));
+ assertTrue(set.contains("4"));
}
@Test(expected = NullPointerException.class)
@@ -1543,11 +1536,11 @@ public class CollectionUtilsTest extends MockTestCase {
assertFalse(CollectionUtils.isFull(set));
final CircularFifoQueue<String> buf = new CircularFifoQueue<>(set);
- assertEquals(false, CollectionUtils.isFull(buf));
+ assertFalse(CollectionUtils.isFull(buf));
buf.remove("2");
assertFalse(CollectionUtils.isFull(buf));
buf.add("2");
- assertEquals(false, CollectionUtils.isFull(buf));
+ assertFalse(CollectionUtils.isFull(buf));
}
@Test(expected = NullPointerException.class)
@@ -1585,15 +1578,11 @@ public class CollectionUtilsTest extends MockTestCase {
@Test
public void intersectionUsesMethodEquals() {
// Let elta and eltb be objects...
- final Integer elta = new Integer(17); // Cannot use valueOf here
- final Integer eltb = new Integer(17);
-
- // ...which are equal...
- assertEquals(elta, eltb);
- assertEquals(eltb, elta);
+ final Integer elta = 17;
+ final Integer eltb = 17;
- // ...but not the same (==).
- assertTrue(elta != eltb);
+ // ...which are the same (==)
+ assertSame(elta, eltb);
// Let cola and colb be collections...
final Collection<Number> cola = new ArrayList<>();
@@ -1613,7 +1602,7 @@ public class CollectionUtilsTest extends MockTestCase {
// or eltb, although this isn't strictly part of the
// contract.
final Object eltc = intersection.iterator().next();
- assertTrue(eltc == elta && eltc != eltb || eltc != elta && eltc == eltb);
+ assertTrue(eltc == elta && eltc == eltb);
// In any event, this element remains equal,
// to both elta and eltb.
@@ -1638,17 +1627,17 @@ public class CollectionUtilsTest extends MockTestCase {
final Collection<String> result = CollectionUtils.retainAll(base, sub);
assertEquals(2, result.size());
- assertEquals(true, result.contains("A"));
+ assertTrue(result.contains("A"));
assertFalse(result.contains("B"));
- assertEquals(true, result.contains("C"));
+ assertTrue(result.contains("C"));
assertEquals(3, base.size());
- assertEquals(true, base.contains("A"));
- assertEquals(true, base.contains("B"));
- assertEquals(true, base.contains("C"));
+ assertTrue(base.contains("A"));
+ assertTrue(base.contains("B"));
+ assertTrue(base.contains("C"));
assertEquals(3, sub.size());
- assertEquals(true, sub.contains("A"));
- assertEquals(true, sub.contains("C"));
- assertEquals(true, sub.contains("X"));
+ assertTrue(sub.contains("A"));
+ assertTrue(sub.contains("C"));
+ assertTrue(sub.contains("X"));
}
@Test(expected = NullPointerException.class)
@@ -1788,16 +1777,16 @@ public class CollectionUtilsTest extends MockTestCase {
final Collection<String> result = CollectionUtils.removeAll(base, sub);
assertEquals(1, result.size());
assertFalse(result.contains("A"));
- assertEquals(true, result.contains("B"));
+ assertTrue(result.contains("B"));
assertFalse(result.contains("C"));
assertEquals(3, base.size());
- assertEquals(true, base.contains("A"));
- assertEquals(true, base.contains("B"));
- assertEquals(true, base.contains("C"));
+ assertTrue(base.contains("A"));
+ assertTrue(base.contains("B"));
+ assertTrue(base.contains("C"));
assertEquals(3, sub.size());
- assertEquals(true, sub.contains("A"));
- assertEquals(true, sub.contains("C"));
- assertEquals(true, sub.contains("X"));
+ assertTrue(sub.contains("A"));
+ assertTrue(sub.contains("C"));
+ assertTrue(sub.contains("X"));
}
@Test(expected = NullPointerException.class)
@@ -1841,9 +1830,9 @@ public class CollectionUtilsTest extends MockTestCase {
list.add("2");
list.add("3");
final Collection<Object> result = CollectionUtils.transformingCollection(list, TRANSFORM_TO_INTEGER);
- assertEquals(true, result.contains("1")); // untransformed
- assertEquals(true, result.contains("2")); // untransformed
- assertEquals(true, result.contains("3")); // untransformed
+ assertTrue(result.contains("1")); // untransformed
+ assertTrue(result.contains("2")); // untransformed
+ assertTrue(result.contains("3")); // untransformed
}
@Test
@@ -2196,13 +2185,13 @@ public class CollectionUtilsTest extends MockTestCase {
assertTrue(result.contains("BB"));
assertFalse(result.contains("CA"));
assertEquals(3, base.size());
- assertEquals(true, base.contains("AC"));
- assertEquals(true, base.contains("BB"));
- assertEquals(true, base.contains("CA"));
+ assertTrue(base.contains("AC"));
+ assertTrue(base.contains("BB"));
+ assertTrue(base.contains("CA"));
assertEquals(3, remove.size());
- assertEquals(true, remove.contains("AA"));
- assertEquals(true, remove.contains("CX"));
- assertEquals(true, remove.contains("XZ"));
+ assertTrue(remove.contains("AA"));
+ assertTrue(remove.contains("CX"));
+ assertTrue(remove.contains("XZ"));
try {
CollectionUtils.removeAll(null, null, DefaultEquator.defaultEquator());
diff --git a/src/test/java/org/apache/commons/collections4/ComparatorUtilsTest.java b/src/test/java/org/apache/commons/collections4/ComparatorUtilsTest.java
index 040974a..ae9af09 100644
--- a/src/test/java/org/apache/commons/collections4/ComparatorUtilsTest.java
+++ b/src/test/java/org/apache/commons/collections4/ComparatorUtilsTest.java
@@ -29,17 +29,16 @@ import org.junit.Test;
*
*/
public class ComparatorUtilsTest {
-
@Test
public void booleanComparator() {
Comparator<Boolean> comp = ComparatorUtils.booleanComparator(true);
assertTrue(comp.compare(Boolean.TRUE, Boolean.FALSE) < 0);
- assertTrue(comp.compare(Boolean.TRUE, Boolean.TRUE) == 0);
+ assertEquals(0, comp.compare(Boolean.TRUE, Boolean.TRUE));
assertTrue(comp.compare(Boolean.FALSE, Boolean.TRUE) > 0);
comp = ComparatorUtils.booleanComparator(false);
assertTrue(comp.compare(Boolean.TRUE, Boolean.FALSE) > 0);
- assertTrue(comp.compare(Boolean.TRUE, Boolean.TRUE) == 0);
+ assertEquals(0, comp.compare(Boolean.TRUE, Boolean.TRUE));
assertTrue(comp.compare(Boolean.FALSE, Boolean.TRUE) < 0);
}
@@ -47,9 +46,9 @@ public class ComparatorUtilsTest {
public void chainedComparator() {
// simple test: chain 2 natural comparators
final Comparator<Integer> comp = ComparatorUtils.chainedComparator(ComparatorUtils.<Integer>naturalComparator(),
- ComparatorUtils.<Integer>naturalComparator());
+ ComparatorUtils.naturalComparator());
assertTrue(comp.compare(1, 2) < 0);
- assertTrue(comp.compare(1, 1) == 0);
+ assertEquals(0, comp.compare(1, 1));
assertTrue(comp.compare(2, 1) > 0);
}
@@ -109,7 +108,7 @@ public class ComparatorUtilsTest {
public void nullLowComparator() {
final Comparator<Integer> comp = ComparatorUtils.nullLowComparator(null);
assertTrue(comp.compare(null, 10) < 0);
- assertTrue(comp.compare(null, null) == 0);
+ assertEquals(0, comp.compare(null, null));
assertTrue(comp.compare(10, null) > 0);
}
@@ -117,8 +116,7 @@ public class ComparatorUtilsTest {
public void nullHighComparator() {
final Comparator<Integer> comp = ComparatorUtils.nullHighComparator(null);
assertTrue(comp.compare(null, 10) > 0);
- assertTrue(comp.compare(null, null) == 0);
+ assertEquals(0, comp.compare(null, null));
assertTrue(comp.compare(10, null) < 0);
}
-
}
diff --git a/src/test/java/org/apache/commons/collections4/FactoryUtilsTest.java b/src/test/java/org/apache/commons/collections4/FactoryUtilsTest.java
index 437dcd6..b003a94 100644
--- a/src/test/java/org/apache/commons/collections4/FactoryUtilsTest.java
+++ b/src/test/java/org/apache/commons/collections4/FactoryUtilsTest.java
@@ -18,6 +18,7 @@ package org.apache.commons.collections4;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
@@ -103,7 +104,7 @@ public class FactoryUtilsTest {
final Factory<Date> factory = FactoryUtils.prototypeFactory(proto);
assertNotNull(factory);
final Date created = factory.create();
- assertTrue(proto != created);
+ assertNotSame(proto, created);
assertEquals(proto, created);
}
@@ -113,17 +114,17 @@ public class FactoryUtilsTest {
final Factory<Object> factory = FactoryUtils.<Object>prototypeFactory(proto);
assertNotNull(factory);
final Object created = factory.create();
- assertTrue(proto != created);
+ assertNotSame(proto, created);
assertEquals(proto, created);
}
@Test
public void testPrototypeFactoryPublicSerialization() throws Exception {
- final Integer proto = Integer.valueOf(9);
+ final Integer proto = 9;
final Factory<Integer> factory = FactoryUtils.prototypeFactory(proto);
assertNotNull(factory);
final Integer created = factory.create();
- assertTrue(proto != created);
+ assertNotSame(proto, created);
assertEquals(proto, created);
}
diff --git a/src/test/java/org/apache/commons/collections4/IterableUtilsTest.java b/src/test/java/org/apache/commons/collections4/IterableUtilsTest.java
index b826f72..b26d9c1 100644
--- a/src/test/java/org/apache/commons/collections4/IterableUtilsTest.java
+++ b/src/test/java/org/apache/commons/collections4/IterableUtilsTest.java
@@ -266,12 +266,12 @@ public class IterableUtilsTest {
@Test
public void find() {
- Predicate<Number> testPredicate = equalPredicate((Number) 4);
+ Predicate<Number> testPredicate = equalPredicate(4);
Integer test = IterableUtils.find(iterableA, testPredicate);
- assertTrue(test.equals(4));
- testPredicate = equalPredicate((Number) 45);
+ assertEquals(4, (int) test);
+ testPredicate = equalPredicate(45);
test = IterableUtils.find(iterableA, testPredicate);
- assertTrue(test == null);
+ assertNull(test);
assertNull(IterableUtils.find(null, testPredicate));
try {
IterableUtils.find(iterableA, null);
@@ -344,7 +344,7 @@ public class IterableUtilsTest {
assertFalse(IterableUtils.matchesAny(list, EQUALS_TWO));
list.add(2);
- assertEquals(true, IterableUtils.matchesAny(list, EQUALS_TWO));
+ assertTrue(IterableUtils.matchesAny(list, EQUALS_TWO));
}
@Test
diff --git a/src/test/java/org/apache/commons/collections4/MultiMapUtilsTest.java b/src/test/java/org/apache/commons/collections4/MultiMapUtilsTest.java
index 4806ba0..fca9123 100644
--- a/src/test/java/org/apache/commons/collections4/MultiMapUtilsTest.java
+++ b/src/test/java/org/apache/commons/collections4/MultiMapUtilsTest.java
@@ -22,7 +22,9 @@ import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
+import java.util.Arrays;
import java.util.Collection;
+import java.util.HashSet;
import java.util.List;
import java.util.Set;
@@ -70,61 +72,54 @@ public class MultiMapUtilsTest {
@Test
public void testIsEmptyWithEmptyMap() {
- final MultiValuedMap<Object, Object> map = new ArrayListValuedHashMap<>();
- assertEquals(true, MultiMapUtils.isEmpty(map));
+ assertTrue(MultiMapUtils.isEmpty(new ArrayListValuedHashMap<>()));
}
@Test
public void testIsEmptyWithNonEmptyMap() {
final MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();
map.put("item", "value");
- assertEquals(false, MultiMapUtils.isEmpty(map));
+ assertFalse(MultiMapUtils.isEmpty(map));
}
@Test
public void testIsEmptyWithNull() {
- final MultiValuedMap<Object, Object> map = null;
- assertEquals(true, MultiMapUtils.isEmpty(map));
+ assertTrue(MultiMapUtils.isEmpty(null));
}
@Test
public void testGetCollection() {
assertNull(MultiMapUtils.getCollection(null, "key1"));
- final String values[] = { "v1", "v2", "v3" };
+ final String[] values = { "v1", "v2", "v3" };
final MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();
for (final String val : values) {
map.put("key1", val);
}
final Collection<String> col = MultiMapUtils.getCollection(map, "key1");
- for (final String val : values) {
- assertTrue(col.contains(val));
- }
+ assertEquals(Arrays.asList(values), col);
}
@Test
public void testGetValuesAsList() {
assertNull(MultiMapUtils.getValuesAsList(null, "key1"));
- final String values[] = { "v1", "v2", "v3" };
+ final String[] values = { "v1", "v2", "v3" };
final MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();
for (final String val : values) {
map.put("key1", val);
}
final List<String> list = MultiMapUtils.getValuesAsList(map, "key1");
- int i = 0;
- for (final String val : list) {
- assertTrue(val.equals(values[i++]));
- }
+ assertEquals(Arrays.asList(values), list);
}
@Test
public void testGetValuesAsSet() {
assertNull(MultiMapUtils.getValuesAsList(null, "key1"));
- final String values[] = { "v1", "v2", "v3" };
+ final String[] values = { "v1", "v2", "v3" };
final MultiValuedMap<String, String> map = new ArrayListValuedHashMap<>();
for (final String val : values) {
map.put("key1", val);
@@ -132,10 +127,7 @@ public class MultiMapUtilsTest {
}
final Set<String> set = MultiMapUtils.getValuesAsSet(map, "key1");
- assertEquals(3, set.size());
- for (final String val : values) {
- assertTrue(set.contains(val));
- }
+ assertEquals(new HashSet<>(Arrays.asList(values)), set);
}
@Test
diff --git a/src/test/java/org/apache/commons/collections4/PredicateUtilsTest.java b/src/test/java/org/apache/commons/collections4/PredicateUtilsTest.java
index 3613a8c..5cb4971 100644
--- a/src/test/java/org/apache/commons/collections4/PredicateUtilsTest.java
+++ b/src/test/java/org/apache/commons/collections4/PredicateUtilsTest.java
@@ -21,6 +21,7 @@ import static org.apache.commons.collections4.functors.TruePredicate.*;
import static org.junit.Assert.*;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
@@ -71,10 +72,10 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
public void testIsNotNullPredicate() {
assertNotNull(PredicateUtils.notNullPredicate());
assertSame(PredicateUtils.notNullPredicate(), PredicateUtils.notNullPredicate());
- assertEquals(false, PredicateUtils.notNullPredicate().evaluate(null));
- assertEquals(true, PredicateUtils.notNullPredicate().evaluate(cObject));
- assertEquals(true, PredicateUtils.notNullPredicate().evaluate(cString));
- assertEquals(true, PredicateUtils.notNullPredicate().evaluate(cInteger));
+ assertFalse(PredicateUtils.notNullPredicate().evaluate(null));
+ assertTrue(PredicateUtils.notNullPredicate().evaluate(cObject));
+ assertTrue(PredicateUtils.notNullPredicate().evaluate(cString));
+ assertTrue(PredicateUtils.notNullPredicate().evaluate(cInteger));
}
// identityPredicate
@@ -83,12 +84,12 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@Test
public void testIdentityPredicate() {
assertSame(nullPredicate(), PredicateUtils.identityPredicate(null));
- assertNotNull(PredicateUtils.identityPredicate(Integer.valueOf(6)));
- assertEquals(false, PredicateUtils.identityPredicate(Integer.valueOf(6)).evaluate(null));
- assertEquals(false, PredicateUtils.<Object>identityPredicate(Integer.valueOf(6)).evaluate(cObject));
- assertEquals(false, PredicateUtils.<Object>identityPredicate(Integer.valueOf(6)).evaluate(cString));
- assertEquals(false, PredicateUtils.identityPredicate(new Integer(6)).evaluate(cInteger)); // Cannot use valueOf here
- assertEquals(true, PredicateUtils.identityPredicate(cInteger).evaluate(cInteger));
+ assertNotNull(PredicateUtils.identityPredicate(6));
+ assertFalse(PredicateUtils.identityPredicate(6).evaluate(null));
+ assertFalse(PredicateUtils.<Object>identityPredicate(6).evaluate(cObject));
+ assertFalse(PredicateUtils.<Object>identityPredicate(6).evaluate(cString));
+ assertTrue(PredicateUtils.identityPredicate(6).evaluate(cInteger)); // Cannot use valueOf here
+ assertTrue(PredicateUtils.identityPredicate(cInteger).evaluate(cInteger));
}
// truePredicate
@@ -98,10 +99,10 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
public void testTruePredicate() {
assertNotNull(TruePredicate.truePredicate());
assertSame(TruePredicate.truePredicate(), TruePredicate.truePredicate());
- assertEquals(true, TruePredicate.truePredicate().evaluate(null));
- assertEquals(true, TruePredicate.truePredicate().evaluate(cObject));
- assertEquals(true, TruePredicate.truePredicate().evaluate(cString));
- assertEquals(true, TruePredicate.truePredicate().evaluate(cInteger));
+ assertTrue(truePredicate().evaluate(null));
+ assertTrue(truePredicate().evaluate(cObject));
+ assertTrue(truePredicate().evaluate(cString));
+ assertTrue(truePredicate().evaluate(cInteger));
}
// falsePredicate
@@ -111,10 +112,10 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
public void testFalsePredicate() {
assertNotNull(FalsePredicate.falsePredicate());
assertSame(FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate());
- assertEquals(false, FalsePredicate.falsePredicate().evaluate(null));
- assertEquals(false, FalsePredicate.falsePredicate().evaluate(cObject));
- assertEquals(false, FalsePredicate.falsePredicate().evaluate(cString));
- assertEquals(false, FalsePredicate.falsePredicate().evaluate(cInteger));
+ assertFalse(FalsePredicate.falsePredicate().evaluate(null));
+ assertFalse(FalsePredicate.falsePredicate().evaluate(cObject));
+ assertFalse(FalsePredicate.falsePredicate().evaluate(cString));
+ assertFalse(FalsePredicate.falsePredicate().evaluate(cInteger));
}
// notPredicate
@@ -123,10 +124,10 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@Test
public void testNotPredicate() {
assertNotNull(PredicateUtils.notPredicate(TruePredicate.truePredicate()));
- assertEquals(false, PredicateUtils.notPredicate(TruePredicate.truePredicate()).evaluate(null));
- assertEquals(false, PredicateUtils.notPredicate(TruePredicate.truePredicate()).evaluate(cObject));
- assertEquals(false, PredicateUtils.notPredicate(TruePredicate.truePredicate()).evaluate(cString));
- assertEquals(false, PredicateUtils.notPredicate(TruePredicate.truePredicate()).evaluate(cInteger));
+ assertFalse(PredicateUtils.notPredicate(truePredicate()).evaluate(null));
+ assertFalse(PredicateUtils.notPredicate(truePredicate()).evaluate(cObject));
+ assertFalse(PredicateUtils.notPredicate(truePredicate()).evaluate(cString));
+ assertFalse(PredicateUtils.notPredicate(truePredicate()).evaluate(cInteger));
}
@Test(expected=NullPointerException.class)
@@ -139,10 +140,10 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@Test
public void testAndPredicate() {
- assertEquals(true, PredicateUtils.andPredicate(TruePredicate.truePredicate(), TruePredicate.truePredicate()).evaluate(null));
- assertEquals(false, PredicateUtils.andPredicate(TruePredicate.truePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
- assertEquals(false, PredicateUtils.andPredicate(FalsePredicate.falsePredicate(), TruePredicate.truePredicate()).evaluate(null));
- assertEquals(false, PredicateUtils.andPredicate(FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
+ assertTrue(PredicateUtils.andPredicate(truePredicate(), truePredicate()).evaluate(null));
+ assertFalse(PredicateUtils.andPredicate(truePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
+ assertFalse(PredicateUtils.andPredicate(FalsePredicate.falsePredicate(), truePredicate()).evaluate(null));
+ assertFalse(PredicateUtils.andPredicate(FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
}
@Test(expected=NullPointerException.class)
@@ -156,43 +157,39 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@SuppressWarnings("unchecked")
@Test
public void testAllPredicate() {
- assertTrue(AllPredicate.allPredicate(new Predicate[] {}), null);
- assertEquals(true, AllPredicate.allPredicate(new Predicate[] {
- TruePredicate.truePredicate(), TruePredicate.truePredicate(), TruePredicate.truePredicate()}).evaluate(null));
- assertEquals(false, AllPredicate.allPredicate(new Predicate[] {
- TruePredicate.truePredicate(), FalsePredicate.falsePredicate(), TruePredicate.truePredicate()}).evaluate(null));
- assertEquals(false, AllPredicate.allPredicate(new Predicate[] {
- FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), TruePredicate.truePredicate()}).evaluate(null));
- assertEquals(false, AllPredicate.allPredicate(new Predicate[] {
- FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()}).evaluate(null));
+ assertPredicateTrue(AllPredicate.allPredicate(), null);
+ assertTrue(AllPredicate.allPredicate(truePredicate(), truePredicate(), truePredicate()).evaluate(null));
+ assertFalse(AllPredicate.allPredicate(truePredicate(), FalsePredicate.falsePredicate(), truePredicate()).evaluate(null));
+ assertFalse(AllPredicate.allPredicate(FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), truePredicate()).evaluate(null));
+ assertFalse(AllPredicate.allPredicate(FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
final Collection<Predicate<Object>> coll = new ArrayList<>();
coll.add(TruePredicate.truePredicate());
coll.add(TruePredicate.truePredicate());
coll.add(TruePredicate.truePredicate());
- assertEquals(true, AllPredicate.allPredicate(coll).evaluate(null));
+ assertTrue(AllPredicate.allPredicate(coll).evaluate(null));
coll.clear();
coll.add(TruePredicate.truePredicate());
coll.add(FalsePredicate.falsePredicate());
coll.add(TruePredicate.truePredicate());
- assertEquals(false, AllPredicate.allPredicate(coll).evaluate(null));
+ assertFalse(AllPredicate.allPredicate(coll).evaluate(null));
coll.clear();
coll.add(FalsePredicate.falsePredicate());
coll.add(FalsePredicate.falsePredicate());
coll.add(TruePredicate.truePredicate());
- assertEquals(false, AllPredicate.allPredicate(coll).evaluate(null));
+ assertFalse(AllPredicate.allPredicate(coll).evaluate(null));
coll.clear();
coll.add(FalsePredicate.falsePredicate());
coll.add(FalsePredicate.falsePredicate());
coll.add(FalsePredicate.falsePredicate());
- assertEquals(false, AllPredicate.allPredicate(coll).evaluate(null));
+ assertFalse(AllPredicate.allPredicate(coll).evaluate(null));
coll.clear();
coll.add(FalsePredicate.falsePredicate());
- assertFalse(AllPredicate.allPredicate(coll), null);
+ assertPredicateFalse(AllPredicate.allPredicate(coll), null);
coll.clear();
coll.add(TruePredicate.truePredicate());
- assertTrue(AllPredicate.allPredicate(coll), null);
+ assertPredicateTrue(AllPredicate.allPredicate(coll), null);
coll.clear();
- assertTrue(AllPredicate.allPredicate(coll), null);
+ assertPredicateTrue(AllPredicate.allPredicate(coll), null);
}
@Test(expected=NullPointerException.class)
@@ -206,10 +203,9 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
AllPredicate.<Object>allPredicate(new Predicate[] { null });
}
- @SuppressWarnings("unchecked")
@Test(expected=NullPointerException.class)
public void testAllPredicateEx3() {
- AllPredicate.allPredicate(new Predicate[] { null, null });
+ AllPredicate.allPredicate(null, null);
}
@Test(expected=NullPointerException.class)
@@ -219,7 +215,7 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@Test
public void testAllPredicateEx5() {
- AllPredicate.allPredicate(Collections.<Predicate<Object>>emptyList());
+ AllPredicate.allPredicate(Collections.emptyList());
}
@Test(expected=NullPointerException.class)
@@ -235,10 +231,10 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@Test
public void testOrPredicate() {
- assertEquals(true, PredicateUtils.orPredicate(TruePredicate.truePredicate(), TruePredicate.truePredicate()).evaluate(null));
- assertEquals(true, PredicateUtils.orPredicate(TruePredicate.truePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
- assertEquals(true, PredicateUtils.orPredicate(FalsePredicate.falsePredicate(), TruePredicate.truePredicate()).evaluate(null));
- assertEquals(false, PredicateUtils.orPredicate(FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
+ assertTrue(PredicateUtils.orPredicate(truePredicate(), truePredicate()).evaluate(null));
+ assertTrue(PredicateUtils.orPredicate(truePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
+ assertTrue(PredicateUtils.orPredicate(FalsePredicate.falsePredicate(), truePredicate()).evaluate(null));
+ assertFalse(PredicateUtils.orPredicate(FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
}
@Test(expected=NullPointerException.class)
@@ -252,44 +248,40 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@SuppressWarnings("unchecked")
@Test
public void testAnyPredicate() {
- assertFalse(PredicateUtils.anyPredicate(new Predicate[] {}), null);
-
- assertEquals(true, PredicateUtils.anyPredicate(new Predicate[] {
- TruePredicate.truePredicate(), TruePredicate.truePredicate(), TruePredicate.truePredicate()}).evaluate(null));
- assertEquals(true, PredicateUtils.anyPredicate(new Predicate[] {
- TruePredicate.truePredicate(), FalsePredicate.falsePredicate(), TruePredicate.truePredicate()}).evaluate(null));
- assertEquals(true, PredicateUtils.anyPredicate(new Predicate[] {
- FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), TruePredicate.truePredicate()}).evaluate(null));
- assertEquals(false, PredicateUtils.anyPredicate(new Predicate[] {
- FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()}).evaluate(null));
+ assertPredicateFalse(PredicateUtils.anyPredicate(), null);
+
+ assertTrue(PredicateUtils.anyPredicate(truePredicate(), truePredicate(), truePredicate()).evaluate(null));
+ assertTrue(PredicateUtils.anyPredicate(truePredicate(), FalsePredicate.falsePredicate(), truePredicate()).evaluate(null));
+ assertTrue(PredicateUtils.anyPredicate(FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), truePredicate()).evaluate(null));
+ assertFalse(PredicateUtils.anyPredicate(FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
final Collection<Predicate<Object>> coll = new ArrayList<>();
coll.add(TruePredicate.truePredicate());
coll.add(TruePredicate.truePredicate());
coll.add(TruePredicate.truePredicate());
- assertEquals(true, PredicateUtils.anyPredicate(coll).evaluate(null));
+ assertTrue(PredicateUtils.anyPredicate(coll).evaluate(null));
coll.clear();
coll.add(TruePredicate.truePredicate());
coll.add(FalsePredicate.falsePredicate());
coll.add(TruePredicate.truePredicate());
- assertEquals(true, PredicateUtils.anyPredicate(coll).evaluate(null));
+ assertTrue(PredicateUtils.anyPredicate(coll).evaluate(null));
coll.clear();
coll.add(FalsePredicate.falsePredicate());
coll.add(FalsePredicate.falsePredicate());
coll.add(TruePredicate.truePredicate());
- assertEquals(true, PredicateUtils.anyPredicate(coll).evaluate(null));
+ assertTrue(PredicateUtils.anyPredicate(coll).evaluate(null));
coll.clear();
coll.add(FalsePredicate.falsePredicate());
coll.add(FalsePredicate.falsePredicate());
coll.add(FalsePredicate.falsePredicate());
- assertEquals(false, PredicateUtils.anyPredicate(coll).evaluate(null));
+ assertFalse(PredicateUtils.anyPredicate(coll).evaluate(null));
coll.clear();
coll.add(FalsePredicate.falsePredicate());
- assertFalse(PredicateUtils.anyPredicate(coll), null);
+ assertPredicateFalse(PredicateUtils.anyPredicate(coll), null);
coll.clear();
coll.add(TruePredicate.truePredicate());
- assertTrue(PredicateUtils.anyPredicate(coll), null);
+ assertPredicateTrue(PredicateUtils.anyPredicate(coll), null);
coll.clear();
- assertFalse(PredicateUtils.anyPredicate(coll), null);
+ assertPredicateFalse(PredicateUtils.anyPredicate(coll), null);
}
@Test(expected=NullPointerException.class)
@@ -303,10 +295,9 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
PredicateUtils.anyPredicate(new Predicate[] {null});
}
- @SuppressWarnings("unchecked")
@Test(expected=NullPointerException.class)
public void testAnyPredicateEx3() {
- PredicateUtils.anyPredicate(new Predicate[] {null, null});
+ PredicateUtils.anyPredicate(null, null);
}
@Test(expected=NullPointerException.class)
@@ -316,7 +307,7 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@Test
public void testAnyPredicateEx5() {
- PredicateUtils.anyPredicate(Collections.<Predicate<Object>>emptyList());
+ PredicateUtils.anyPredicate(Collections.emptyList());
}
@Test(expected=NullPointerException.class)
@@ -332,10 +323,10 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@Test
public void testEitherPredicate() {
- assertEquals(false, PredicateUtils.eitherPredicate(TruePredicate.truePredicate(), TruePredicate.truePredicate()).evaluate(null));
- assertEquals(true, PredicateUtils.eitherPredicate(TruePredicate.truePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
- assertEquals(true, PredicateUtils.eitherPredicate(FalsePredicate.falsePredicate(), TruePredicate.truePredicate()).evaluate(null));
- assertEquals(false, PredicateUtils.eitherPredicate(FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
+ assertFalse(PredicateUtils.eitherPredicate(truePredicate(), truePredicate()).evaluate(null));
+ assertTrue(PredicateUtils.eitherPredicate(truePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
+ assertTrue(PredicateUtils.eitherPredicate(FalsePredicate.falsePredicate(), truePredicate()).evaluate(null));
+ assertFalse(PredicateUtils.eitherPredicate(FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
}
@Test(expected=NullPointerException.class)
@@ -349,47 +340,41 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@SuppressWarnings("unchecked")
@Test
public void testOnePredicate() {
- assertFalse(PredicateUtils.onePredicate((Predicate<Object>[]) new Predicate[] {}), null);
- assertEquals(false, PredicateUtils.onePredicate(new Predicate[] {
- TruePredicate.truePredicate(), TruePredicate.truePredicate(), TruePredicate.truePredicate()}).evaluate(null));
- assertEquals(false, PredicateUtils.onePredicate(new Predicate[] {
- TruePredicate.truePredicate(), FalsePredicate.falsePredicate(), TruePredicate.truePredicate()}).evaluate(null));
- assertEquals(true, PredicateUtils.onePredicate(new Predicate[] {
- TruePredicate.truePredicate(), FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()}).evaluate(null));
- assertEquals(true, PredicateUtils.onePredicate(new Predicate[] {
- FalsePredicate.falsePredicate(), TruePredicate.truePredicate(), FalsePredicate.falsePredicate()}).evaluate(null));
- assertEquals(true, PredicateUtils.onePredicate(new Predicate[] {
- FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), TruePredicate.truePredicate()}).evaluate(null));
- assertEquals(false, PredicateUtils.onePredicate(new Predicate[] {
- FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()}).evaluate(null));
+ assertPredicateFalse(PredicateUtils.onePredicate((Predicate<Object>[]) new Predicate[] {}), null);
+ assertFalse(PredicateUtils.onePredicate(truePredicate(), truePredicate(), truePredicate()).evaluate(null));
+ assertFalse(PredicateUtils.onePredicate(truePredicate(), FalsePredicate.falsePredicate(), truePredicate()).evaluate(null));
+ assertTrue(PredicateUtils.onePredicate(truePredicate(), FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
+ assertTrue(PredicateUtils.onePredicate(FalsePredicate.falsePredicate(), truePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
+ assertTrue(PredicateUtils.onePredicate(FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), truePredicate()).evaluate(null));
+ assertFalse(PredicateUtils.onePredicate(FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
final Collection<Predicate<Object>> coll = new ArrayList<>();
coll.add(TruePredicate.truePredicate());
coll.add(TruePredicate.truePredicate());
coll.add(TruePredicate.truePredicate());
- assertEquals(false, PredicateUtils.onePredicate(coll).evaluate(null));
+ assertFalse(PredicateUtils.onePredicate(coll).evaluate(null));
coll.clear();
coll.add(TruePredicate.truePredicate());
coll.add(FalsePredicate.falsePredicate());
coll.add(TruePredicate.truePredicate());
- assertEquals(false, PredicateUtils.onePredicate(coll).evaluate(null));
+ assertFalse(PredicateUtils.onePredicate(coll).evaluate(null));
coll.clear();
coll.add(FalsePredicate.falsePredicate());
coll.add(FalsePredicate.falsePredicate());
coll.add(TruePredicate.truePredicate());
- assertEquals(true, PredicateUtils.onePredicate(coll).evaluate(null));
+ assertTrue(PredicateUtils.onePredicate(coll).evaluate(null));
coll.clear();
coll.add(FalsePredicate.falsePredicate());
coll.add(FalsePredicate.falsePredicate());
coll.add(FalsePredicate.falsePredicate());
- assertEquals(false, PredicateUtils.onePredicate(coll).evaluate(null));
+ assertFalse(PredicateUtils.onePredicate(coll).evaluate(null));
coll.clear();
coll.add(FalsePredicate.falsePredicate());
- assertFalse(PredicateUtils.onePredicate(coll), null);
+ assertPredicateFalse(PredicateUtils.onePredicate(coll), null);
coll.clear();
coll.add(TruePredicate.truePredicate());
- assertTrue(PredicateUtils.onePredicate(coll), null);
+ assertPredicateTrue(PredicateUtils.onePredicate(coll), null);
coll.clear();
- assertFalse(PredicateUtils.onePredicate(coll), null);
+ assertPredicateFalse(PredicateUtils.onePredicate(coll), null);
}
@Test(expected=NullPointerException.class)
@@ -403,10 +388,9 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
PredicateUtils.onePredicate(new Predicate[] {null});
}
- @SuppressWarnings("unchecked")
@Test(expected=NullPointerException.class)
public void testOnePredicateEx3() {
- PredicateUtils.onePredicate(new Predicate[] {null, null});
+ PredicateUtils.onePredicate(null, null);
}
@Test(expected=NullPointerException.class)
@@ -422,10 +406,7 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@Test(expected=NullPointerException.class)
public void testOnePredicateEx6() {
- final Collection<Predicate<Object>> coll = new ArrayList<>();
- coll.add(null);
- coll.add(null);
- PredicateUtils.onePredicate(coll);
+ PredicateUtils.onePredicate(Arrays.asList(null, null));
}
// neitherPredicate
@@ -433,10 +414,10 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@Test
public void testNeitherPredicate() {
- assertEquals(false, PredicateUtils.neitherPredicate(TruePredicate.truePredicate(), TruePredicate.truePredicate()).evaluate(null));
- assertEquals(false, PredicateUtils.neitherPredicate(TruePredicate.truePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
- assertEquals(false, PredicateUtils.neitherPredicate(FalsePredicate.falsePredicate(), TruePredicate.truePredicate()).evaluate(null));
- assertEquals(true, PredicateUtils.neitherPredicate(FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
+ assertFalse(PredicateUtils.neitherPredicate(truePredicate(), truePredicate()).evaluate(null));
+ assertFalse(PredicateUtils.neitherPredicate(truePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
+ assertFalse(PredicateUtils.neitherPredicate(FalsePredicate.falsePredicate(), truePredicate()).evaluate(null));
+ assertTrue(PredicateUtils.neitherPredicate(FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
}
@Test(expected=NullPointerException.class)
@@ -450,43 +431,39 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@SuppressWarnings("unchecked")
@Test
public void testNonePredicate() {
- assertTrue(PredicateUtils.nonePredicate(new Predicate[] {}), null);
- assertEquals(false, PredicateUtils.nonePredicate(new Predicate[] {
- TruePredicate.truePredicate(), TruePredicate.truePredicate(), TruePredicate.truePredicate() }).evaluate(null));
- assertEquals(false, PredicateUtils.nonePredicate(new Predicate[] {
- TruePredicate.truePredicate(), FalsePredicate.falsePredicate(), TruePredicate.truePredicate() }).evaluate(null));
- assertEquals(false, PredicateUtils.nonePredicate(new Predicate[] {
- FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), TruePredicate.truePredicate() }).evaluate(null));
- assertEquals(true, PredicateUtils.nonePredicate(new Predicate[] {
- FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate() }).evaluate(null));
+ assertPredicateTrue(PredicateUtils.nonePredicate(), null);
+ assertFalse(PredicateUtils.nonePredicate(truePredicate(), truePredicate(), truePredicate()).evaluate(null));
+ assertFalse(PredicateUtils.nonePredicate(truePredicate(), FalsePredicate.falsePredicate(), truePredicate()).evaluate(null));
+ assertFalse(PredicateUtils.nonePredicate(FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), truePredicate()).evaluate(null));
+ assertTrue(PredicateUtils.nonePredicate(FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
final Collection<Predicate<Object>> coll = new ArrayList<>();
coll.add(TruePredicate.truePredicate());
coll.add(TruePredicate.truePredicate());
coll.add(TruePredicate.truePredicate());
- assertEquals(false, PredicateUtils.nonePredicate(coll).evaluate(null));
+ assertFalse(PredicateUtils.nonePredicate(coll).evaluate(null));
coll.clear();
coll.add(TruePredicate.truePredicate());
coll.add(FalsePredicate.falsePredicate());
coll.add(TruePredicate.truePredicate());
- assertEquals(false, PredicateUtils.nonePredicate(coll).evaluate(null));
+ assertFalse(PredicateUtils.nonePredicate(coll).evaluate(null));
coll.clear();
coll.add(FalsePredicate.falsePredicate());
coll.add(FalsePredicate.falsePredicate());
coll.add(TruePredicate.truePredicate());
- assertEquals(false, PredicateUtils.nonePredicate(coll).evaluate(null));
+ assertFalse(PredicateUtils.nonePredicate(coll).evaluate(null));
coll.clear();
coll.add(FalsePredicate.falsePredicate());
coll.add(FalsePredicate.falsePredicate());
coll.add(FalsePredicate.falsePredicate());
- assertEquals(true, PredicateUtils.nonePredicate(coll).evaluate(null));
+ assertTrue(PredicateUtils.nonePredicate(coll).evaluate(null));
coll.clear();
coll.add(FalsePredicate.falsePredicate());
- assertTrue(PredicateUtils.nonePredicate(coll), null);
+ assertPredicateTrue(PredicateUtils.nonePredicate(coll), null);
coll.clear();
coll.add(TruePredicate.truePredicate());
- assertFalse(PredicateUtils.nonePredicate(coll), null);
+ assertPredicateFalse(PredicateUtils.nonePredicate(coll), null);
coll.clear();
- assertTrue(PredicateUtils.nonePredicate(coll), null);
+ assertPredicateTrue(PredicateUtils.nonePredicate(coll), null);
}
@Test(expected=NullPointerException.class)
@@ -503,7 +480,7 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@SuppressWarnings("unchecked")
@Test(expected=NullPointerException.class)
public void testNonePredicateEx3() {
- PredicateUtils.nonePredicate(new Predicate[] {null, null});
+ PredicateUtils.nonePredicate(null, null);
}
@Test(expected=NullPointerException.class)
@@ -513,7 +490,7 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@Test
public void testNonePredicateEx5() {
- PredicateUtils.nonePredicate(Collections.<Predicate<Object>>emptyList());
+ PredicateUtils.nonePredicate(Collections.emptyList());
}
@Test(expected=NullPointerException.class)
@@ -530,10 +507,10 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@Test
public void testInstanceOfPredicate() {
assertNotNull(PredicateUtils.instanceofPredicate(String.class));
- assertEquals(false, PredicateUtils.instanceofPredicate(String.class).evaluate(null));
- assertEquals(false, PredicateUtils.instanceofPredicate(String.class).evaluate(cObject));
- assertEquals(true, PredicateUtils.instanceofPredicate(String.class).evaluate(cString));
- assertEquals(false, PredicateUtils.instanceofPredicate(String.class).evaluate(cInteger));
+ assertFalse(PredicateUtils.instanceofPredicate(String.class).evaluate(null));
+ assertFalse(PredicateUtils.instanceofPredicate(String.class).evaluate(cObject));
+ assertTrue(PredicateUtils.instanceofPredicate(String.class).evaluate(cString));
+ assertFalse(PredicateUtils.instanceofPredicate(String.class).evaluate(cInteger));
}
// uniquePredicate
@@ -542,12 +519,12 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@Test
public void testUniquePredicate() {
final Predicate<Object> p = PredicateUtils.uniquePredicate();
- assertEquals(true, p.evaluate(new Object()));
- assertEquals(true, p.evaluate(new Object()));
- assertEquals(true, p.evaluate(new Object()));
- assertEquals(true, p.evaluate(cString));
- assertEquals(false, p.evaluate(cString));
- assertEquals(false, p.evaluate(cString));
+ assertTrue(p.evaluate(new Object()));
+ assertTrue(p.evaluate(new Object()));
+ assertTrue(p.evaluate(new Object()));
+ assertTrue(p.evaluate(cString));
+ assertFalse(p.evaluate(cString));
+ assertFalse(p.evaluate(cString));
}
// asPredicate(Transformer)
@@ -555,8 +532,8 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@Test
public void testAsPredicateTransformer() {
- assertEquals(false, PredicateUtils.asPredicate(TransformerUtils.<Boolean>nopTransformer()).evaluate(false));
- assertEquals(true, PredicateUtils.asPredicate(TransformerUtils.<Boolean>nopTransformer()).evaluate(true));
+ assertFalse(PredicateUtils.asPredicate(TransformerUtils.nopTransformer()).evaluate(false));
+ assertTrue(PredicateUtils.asPredicate(TransformerUtils.nopTransformer()).evaluate(true));
}
@Test(expected=NullPointerException.class)
@@ -566,7 +543,7 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@Test(expected=FunctorException.class)
public void testAsPredicateTransformerEx2() {
- PredicateUtils.asPredicate(TransformerUtils.<Boolean>nopTransformer()).evaluate(null);
+ PredicateUtils.asPredicate(TransformerUtils.nopTransformer()).evaluate(null);
}
// invokerPredicate
@@ -575,9 +552,9 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@Test
public void testInvokerPredicate() {
final List<Object> list = new ArrayList<>();
- assertEquals(true, PredicateUtils.invokerPredicate("isEmpty").evaluate(list));
+ assertTrue(PredicateUtils.invokerPredicate("isEmpty").evaluate(list));
list.add(new Object());
- assertEquals(false, PredicateUtils.invokerPredicate("isEmpty").evaluate(list));
+ assertFalse(PredicateUtils.invokerPredicate("isEmpty").evaluate(list));
}
@Test(expected=NullPointerException.class)
@@ -601,11 +578,11 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@Test
public void testInvokerPredicate2() {
final List<String> list = new ArrayList<>();
- assertEquals(false, PredicateUtils.invokerPredicate(
- "contains", new Class[] {Object.class}, new Object[] {cString}).evaluate(list));
+ assertFalse(PredicateUtils.invokerPredicate(
+ "contains", new Class[]{Object.class}, new Object[]{cString}).evaluate(list));
list.add(cString);
- assertEquals(true, PredicateUtils.invokerPredicate(
- "contains", new Class[] {Object.class}, new Object[] {cString}).evaluate(list));
+ assertTrue(PredicateUtils.invokerPredicate(
+ "contains", new Class[]{Object.class}, new Object[]{cString}).evaluate(list));
}
@Test(expected=NullPointerException.class)
@@ -629,7 +606,7 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@Test(expected=FunctorException.class)
public void testNullIsExceptionPredicate() {
- assertEquals(true, PredicateUtils.nullIsExceptionPredicate(TruePredicate.truePredicate()).evaluate(new Object()));
+ assertTrue(PredicateUtils.nullIsExceptionPredicate(truePredicate()).evaluate(new Object()));
PredicateUtils.nullIsExceptionPredicate(TruePredicate.truePredicate()).evaluate(null);
}
@@ -643,9 +620,9 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@Test
public void testNullIsTruePredicate() {
- assertEquals(true, PredicateUtils.nullIsTruePredicate(TruePredicate.truePredicate()).evaluate(null));
- assertEquals(true, PredicateUtils.nullIsTruePredicate(TruePredicate.truePredicate()).evaluate(new Object()));
- assertEquals(false, PredicateUtils.nullIsTruePredicate(FalsePredicate.falsePredicate()).evaluate(new Object()));
+ assertTrue(PredicateUtils.nullIsTruePredicate(truePredicate()).evaluate(null));
+ assertTrue(PredicateUtils.nullIsTruePredicate(truePredicate()).evaluate(new Object()));
+ assertFalse(PredicateUtils.nullIsTruePredicate(FalsePredicate.falsePredicate()).evaluate(new Object()));
}
@Test(expected=NullPointerException.class)
@@ -658,9 +635,9 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@Test
public void testNullIsFalsePredicate() {
- assertEquals(false, PredicateUtils.nullIsFalsePredicate(TruePredicate.truePredicate()).evaluate(null));
- assertEquals(true, PredicateUtils.nullIsFalsePredicate(TruePredicate.truePredicate()).evaluate(new Object()));
- assertEquals(false, PredicateUtils.nullIsFalsePredicate(FalsePredicate.falsePredicate()).evaluate(new Object()));
+ assertFalse(PredicateUtils.nullIsFalsePredicate(truePredicate()).evaluate(null));
+ assertTrue(PredicateUtils.nullIsFalsePredicate(truePredicate()).evaluate(new Object()));
+ assertFalse(PredicateUtils.nullIsFalsePredicate(FalsePredicate.falsePredicate()).evaluate(new Object()));
}
@Test(expected=NullPointerException.class)
@@ -673,16 +650,16 @@ public class PredicateUtilsTest extends AbstractPredicateTest {
@Test
public void testTransformedPredicate() {
- assertEquals(true, PredicateUtils.transformedPredicate(
+ assertTrue(PredicateUtils.transformedPredicate(
TransformerUtils.nopTransformer(),
- TruePredicate.truePredicate()).evaluate(new Object()));
+ truePredicate()).evaluate(new Object()));
final Map<Object, Object> map = new HashMap<>();
map.put(Boolean.TRUE, "Hello");
final Transformer<Object, Object> t = TransformerUtils.mapTransformer(map);
final Predicate<Object> p = EqualPredicate.<Object>equalPredicate("Hello");
- assertEquals(false, PredicateUtils.transformedPredicate(t, p).evaluate(null));
- assertEquals(true, PredicateUtils.transformedPredicate(t, p).evaluate(Boolean.TRUE));
+ assertFalse(PredicateUtils.transformedPredicate(t, p).evaluate(null));
+ assertTrue(PredicateUtils.transformedPredicate(t, p).evaluate(Boolean.TRUE));
try {
PredicateUtils.transformedPredicate(null, null);
fail();
diff --git a/src/test/java/org/apache/commons/collections4/SetUtilsTest.java b/src/test/java/org/apache/commons/collections4/SetUtilsTest.java
index 123d66c..7936129 100644
--- a/src/test/java/org/apache/commons/collections4/SetUtilsTest.java
+++ b/src/test/java/org/apache/commons/collections4/SetUtilsTest.java
@@ -18,6 +18,8 @@ package org.apache.commons.collections4;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
@@ -161,13 +163,13 @@ public class SetUtilsTest {
final Set<String> a = new HashSet<>(data);
final Set<String> b = new HashSet<>(data);
- assertEquals(true, a.equals(b));
- assertEquals(true, SetUtils.isEqualSet(a, b));
+ assertEquals(a, b);
+ assertTrue(SetUtils.isEqualSet(a, b));
a.clear();
- assertEquals(false, SetUtils.isEqualSet(a, b));
- assertEquals(false, SetUtils.isEqualSet(a, null));
- assertEquals(false, SetUtils.isEqualSet(null, b));
- assertEquals(true, SetUtils.isEqualSet(null, null));
+ assertFalse(SetUtils.isEqualSet(a, b));
+ assertFalse(SetUtils.isEqualSet(a, null));
+ assertFalse(SetUtils.isEqualSet(null, b));
+ assertTrue(SetUtils.isEqualSet(null, null));
}
@Test
@@ -177,12 +179,12 @@ public class SetUtilsTest {
final Set<String> a = new HashSet<>(data);
final Set<String> b = new HashSet<>(data);
- assertEquals(true, a.hashCode() == b.hashCode());
- assertEquals(true, a.hashCode() == SetUtils.hashCodeForSet(a));
- assertEquals(true, b.hashCode() == SetUtils.hashCodeForSet(b));
- assertEquals(true, SetUtils.hashCodeForSet(a) == SetUtils.hashCodeForSet(b));
+ assertEquals(a.hashCode(), b.hashCode());
+ assertEquals(a.hashCode(), SetUtils.hashCodeForSet(a));
+ assertEquals(b.hashCode(), SetUtils.hashCodeForSet(b));
+ assertEquals(SetUtils.hashCodeForSet(a), SetUtils.hashCodeForSet(b));
a.clear();
- assertEquals(false, SetUtils.hashCodeForSet(a) == SetUtils.hashCodeForSet(b));
+ assertNotEquals(SetUtils.hashCodeForSet(a), SetUtils.hashCodeForSet(b));
assertEquals(0, SetUtils.hashCodeForSet(null));
}
@@ -208,7 +210,7 @@ public class SetUtilsTest {
assertTrue("set contains null", set4.contains(null));
final Set<?> set5 = SetUtils.hashSet((Object[]) null);
- assertEquals("set is null", null, set5);
+ assertNull("set is null", set5);
}
@Test
@@ -269,7 +271,7 @@ public class SetUtilsTest {
assertTrue("set contains null", set4.contains(null));
final Set<?> set5 = SetUtils.unmodifiableSet((Object[]) null);
- assertEquals("set is null", null, set5);
+ assertNull("set is null", set5);
}
@Test
diff --git a/src/test/java/org/apache/commons/collections4/TransformerUtilsTest.java b/src/test/java/org/apache/commons/collections4/TransformerUtilsTest.java
index b9f9679..196d74c 100644
--- a/src/test/java/org/apache/commons/collections4/TransformerUtilsTest.java
+++ b/src/test/java/org/apache/commons/collections4/TransformerUtilsTest.java
@@ -18,6 +18,7 @@ package org.apache.commons.collections4;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.fail;
@@ -75,10 +76,10 @@ public class TransformerUtilsTest {
public void testNullTransformer() {
assertNotNull(TransformerUtils.nullTransformer());
assertSame(TransformerUtils.nullTransformer(), TransformerUtils.nullTransformer());
- assertEquals(null, TransformerUtils.nullTransformer().transform(null));
- assertEquals(null, TransformerUtils.nullTransformer().transform(cObject));
- assertEquals(null, TransformerUtils.nullTransformer().transform(cString));
- assertEquals(null, TransformerUtils.nullTransformer().transform(cInteger));
+ assertNull(TransformerUtils.nullTransformer().transform(null));
+ assertNull(TransformerUtils.nullTransformer().transform(cObject));
+ assertNull(TransformerUtils.nullTransformer().transform(cString));
+ assertNull(TransformerUtils.nullTransformer().transform(cInteger));
}
// nopTransformer
@@ -88,7 +89,7 @@ public class TransformerUtilsTest {
public void testNopTransformer() {
assertNotNull(TransformerUtils.nullTransformer());
assertSame(TransformerUtils.nullTransformer(), TransformerUtils.nullTransformer());
- assertEquals(null, TransformerUtils.nopTransformer().transform(null));
+ assertNull(TransformerUtils.nopTransformer().transform(null));
assertEquals(cObject, TransformerUtils.nopTransformer().transform(cObject));
assertEquals(cString, TransformerUtils.nopTransformer().transform(cString));
assertEquals(cInteger, TransformerUtils.nopTransformer().transform(cInteger));
@@ -111,7 +112,7 @@ public class TransformerUtilsTest {
@Test
public void testCloneTransformer() {
- assertEquals(null, TransformerUtils.cloneTransformer().transform(null));
+ assertNull(TransformerUtils.cloneTransformer().transform(null));
assertEquals(cString, TransformerUtils.cloneTransformer().transform(cString));
assertEquals(cInteger, TransformerUtils.cloneTransformer().transform(cInteger));
try {
@@ -135,7 +136,7 @@ public class TransformerUtilsTest {
assertEquals(Integer.valueOf(0), TransformerUtils.mapTransformer(map).transform(null));
assertEquals(Integer.valueOf(1), TransformerUtils.mapTransformer(map).transform(cObject));
assertEquals(Integer.valueOf(2), TransformerUtils.mapTransformer(map).transform(cString));
- assertEquals(null, TransformerUtils.mapTransformer(map).transform(cInteger));
+ assertNull(TransformerUtils.mapTransformer(map).transform(cInteger));
assertSame(ConstantTransformer.NULL_INSTANCE, TransformerUtils.mapTransformer(null));
}
@@ -144,7 +145,7 @@ public class TransformerUtilsTest {
@Test
public void testExecutorTransformer() {
- assertEquals(null, TransformerUtils.asTransformer(ClosureUtils.nopClosure()).transform(null));
+ assertNull(TransformerUtils.asTransformer(ClosureUtils.nopClosure()).transform(null));
assertEquals(cObject, TransformerUtils.asTransformer(ClosureUtils.nopClosure()).transform(cObject));
assertEquals(cString, TransformerUtils.asTransformer(ClosureUtils.nopClosure()).transform(cString));
assertEquals(cInteger, TransformerUtils.asTransformer(ClosureUtils.nopClosure()).transform(cInteger));
@@ -178,10 +179,10 @@ public class TransformerUtilsTest {
@Test
public void testFactoryTransformer() {
- assertEquals(null, TransformerUtils.asTransformer(FactoryUtils.nullFactory()).transform(null));
- assertEquals(null, TransformerUtils.asTransformer(FactoryUtils.nullFactory()).transform(cObject));
- assertEquals(null, TransformerUtils.asTransformer(FactoryUtils.nullFactory()).transform(cString));
- assertEquals(null, TransformerUtils.asTransformer(FactoryUtils.nullFactory()).transform(cInteger));
+ assertNull(TransformerUtils.asTransformer(FactoryUtils.nullFactory()).transform(null));
+ assertNull(TransformerUtils.asTransformer(FactoryUtils.nullFactory()).transform(cObject));
+ assertNull(TransformerUtils.asTransformer(FactoryUtils.nullFactory()).transform(cString));
+ assertNull(TransformerUtils.asTransformer(FactoryUtils.nullFactory()).transform(cInteger));
try {
TransformerUtils.asTransformer((Factory<Object>) null);
} catch (final NullPointerException ex) {
@@ -249,13 +250,13 @@ public class TransformerUtilsTest {
final Predicate<Integer> lessThanFivePredicate = value -> value < 5;
// if/else tests
- assertEquals("A", TransformerUtils.<Integer, String>ifTransformer(lessThanFivePredicate, a, b).transform(1));
- assertEquals("B", TransformerUtils.<Integer, String>ifTransformer(lessThanFivePredicate, a, b).transform(5));
+ assertEquals("A", TransformerUtils.ifTransformer(lessThanFivePredicate, a, b).transform(1));
+ assertEquals("B", TransformerUtils.ifTransformer(lessThanFivePredicate, a, b).transform(5));
// if tests
final Predicate<String> equalsAPredicate = EqualPredicate.equalPredicate("A");
- assertEquals("C", TransformerUtils.<String>ifTransformer(equalsAPredicate, c).transform("A"));
- assertEquals("B", TransformerUtils.<String>ifTransformer(equalsAPredicate, c).transform("B"));
+ assertEquals("C", TransformerUtils.ifTransformer(equalsAPredicate, c).transform("A"));
+ assertEquals("B", TransformerUtils.ifTransformer(equalsAPredicate, c).transform("B"));
try {
TransformerUtils.ifTransformer(null, null);
@@ -288,9 +289,9 @@ public class TransformerUtilsTest {
assertEquals("A", TransformerUtils.switchTransformer(TruePredicate.truePredicate(), a, b).transform(null));
assertEquals("B", TransformerUtils.switchTransformer(FalsePredicate.falsePredicate(), a, b).transform(null));
- assertEquals(null, TransformerUtils.<Object, String>switchTransformer(
- new Predicate[] { EqualPredicate.equalPredicate("HELLO"), EqualPredicate.equalPredicate("THERE") },
- new Transformer[] { a, b }).transform("WELL"));
+ assertNull(TransformerUtils.<Object, String>switchTransformer(
+ new Predicate[]{EqualPredicate.equalPredicate("HELLO"), EqualPredicate.equalPredicate("THERE")},
+ new Transformer[]{a, b}).transform("WELL"));
assertEquals("A", TransformerUtils.switchTransformer(
new Predicate[] { EqualPredicate.equalPredicate("HELLO"), EqualPredicate.equalPredicate("THERE") },
new Transformer[] { a, b }).transform("HELLO"));
@@ -305,7 +306,7 @@ public class TransformerUtilsTest {
Map<Predicate<String>, Transformer<String, String>> map = new HashMap<>();
map.put(EqualPredicate.equalPredicate("HELLO"), a);
map.put(EqualPredicate.equalPredicate("THERE"), b);
- assertEquals(null, TransformerUtils.switchTransformer(map).transform("WELL"));
+ assertNull(TransformerUtils.switchTransformer(map).transform("WELL"));
assertEquals("A", TransformerUtils.switchTransformer(map).transform("HELLO"));
assertEquals("B", TransformerUtils.switchTransformer(map).transform("THERE"));
map.put(null, c);
@@ -322,11 +323,11 @@ public class TransformerUtilsTest {
fail();
} catch (final NullPointerException ex) {}
try {
- TransformerUtils.switchTransformer((Predicate[]) null, (Transformer[]) null);
+ TransformerUtils.switchTransformer(null, (Transformer[]) null);
fail();
} catch (final NullPointerException ex) {}
try {
- TransformerUtils.switchTransformer((Map<Predicate<Object>, Transformer<Object, Object>>) null);
+ TransformerUtils.switchTransformer(null);
fail();
} catch (final NullPointerException ex) {}
try {
@@ -353,7 +354,7 @@ public class TransformerUtilsTest {
Map<String, Transformer<String, String>> map = new HashMap<>();
map.put("HELLO", a);
map.put("THERE", b);
- assertEquals(null, TransformerUtils.switchMapTransformer(map).transform("WELL"));
+ assertNull(TransformerUtils.switchMapTransformer(map).transform("WELL"));
assertEquals("A", TransformerUtils.switchMapTransformer(map).transform("HELLO"));
assertEquals("B", TransformerUtils.switchMapTransformer(map).transform("THERE"));
map.put(null, c);
@@ -376,10 +377,10 @@ public class TransformerUtilsTest {
@Test
public void testInvokerTransformer() {
final List<Object> list = new ArrayList<>();
- assertEquals(Integer.valueOf(0), TransformerUtils.invokerTransformer("size").transform(list));
+ assertEquals(0, TransformerUtils.invokerTransformer("size").transform(list));
list.add(new Object());
- assertEquals(Integer.valueOf(1), TransformerUtils.invokerTransformer("size").transform(list));
- assertEquals(null, TransformerUtils.invokerTransformer("size").transform(null));
+ assertEquals(1, TransformerUtils.invokerTransformer("size").transform(list));
+ assertNull(TransformerUtils.invokerTransformer("size").transform(null));
try {
TransformerUtils.invokerTransformer(null);
@@ -402,8 +403,8 @@ public class TransformerUtilsTest {
list.add(cString);
assertEquals(Boolean.TRUE, TransformerUtils.invokerTransformer("contains",
new Class[] { Object.class }, new Object[] { cString }).transform(list));
- assertEquals(null, TransformerUtils.invokerTransformer("contains",
- new Class[] { Object.class }, new Object[] { cString }).transform(null));
+ assertNull(TransformerUtils.invokerTransformer("contains",
+ new Class[]{Object.class}, new Object[]{cString}).transform(null));
try {
TransformerUtils.invokerTransformer(null, null, null);
@@ -438,7 +439,7 @@ public class TransformerUtilsTest {
assertEquals( "StringValueTransformer should return \"null\" when given a null argument.", "null",
TransformerUtils.stringValueTransformer().transform(null));
assertEquals( "StringValueTransformer should return toString value", "6",
- TransformerUtils.stringValueTransformer().transform(Integer.valueOf(6)));
+ TransformerUtils.stringValueTransformer().transform(6));
}
// instantiateFactory
@@ -464,7 +465,7 @@ public class TransformerUtilsTest {
trans = TransformerUtils.instantiateTransformer();
assertEquals("", trans.transform(String.class));
- trans = TransformerUtils.instantiateTransformer(new Class[] { Long.TYPE }, new Object[] { new Long(1000L) });
+ trans = TransformerUtils.instantiateTransformer(new Class[] { Long.TYPE }, new Object[] {1000L});
assertEquals(new Date(1000L), trans.transform(Date.class));
}
diff --git a/src/test/java/org/apache/commons/collections4/bag/AbstractBagTest.java b/src/test/java/org/apache/commons/collections4/bag/AbstractBagTest.java
index e6cadd8..969280d 100644
--- a/src/test/java/org/apache/commons/collections4/bag/AbstractBagTest.java
+++ b/src/test/java/org/apache/commons/collections4/bag/AbstractBagTest.java
@@ -33,6 +33,8 @@ import org.apache.commons.collections4.BulkTest;
import org.apache.commons.collections4.collection.AbstractCollectionTest;
import org.apache.commons.collections4.set.AbstractSetTest;
+import static org.junit.Assert.assertNotEquals;
+
/**
* Abstract test class for {@link org.apache.commons.collections4.Bag Bag} methods and contracts.
* <p>
@@ -76,8 +78,7 @@ public abstract class AbstractBagTest<T> extends AbstractCollectionTest<T> {
*/
@Override
public Collection<T> makeConfirmedCollection() {
- final ArrayList<T> list = new ArrayList<>();
- return list;
+ return new ArrayList<>();
}
/**
@@ -155,18 +156,18 @@ public abstract class AbstractBagTest<T> extends AbstractCollectionTest<T> {
@SuppressWarnings("unchecked")
public void testBagEqualsSelf() {
final Bag<T> bag = makeObject();
- assertTrue(bag.equals(bag));
+ assertEquals(bag, bag);
if (!isAddSupported()) {
return;
}
bag.add((T) "elt");
- assertTrue(bag.equals(bag));
+ assertEquals(bag, bag);
bag.add((T) "elt"); // again
- assertTrue(bag.equals(bag));
+ assertEquals(bag, bag);
bag.add((T) "elt2");
- assertTrue(bag.equals(bag));
+ assertEquals(bag, bag);
}
@SuppressWarnings("unchecked")
@@ -223,20 +224,20 @@ public abstract class AbstractBagTest<T> extends AbstractCollectionTest<T> {
final Bag<T> bag = makeObject();
- assertEquals("Bag does not have at least 1 'A'", false, bag.contains("A"));
- assertEquals("Bag does not have at least 1 'B'", false, bag.contains("B"));
+ assertFalse("Bag does not have at least 1 'A'", bag.contains("A"));
+ assertFalse("Bag does not have at least 1 'B'", bag.contains("B"));
bag.add((T) "A"); // bag 1A
- assertEquals("Bag has at least 1 'A'", true, bag.contains("A"));
- assertEquals("Bag does not have at least 1 'B'", false, bag.contains("B"));
+ assertTrue("Bag has at least 1 'A'", bag.contains("A"));
+ assertFalse("Bag does not have at least 1 'B'", bag.contains("B"));
bag.add((T) "A"); // bag 2A
- assertEquals("Bag has at least 1 'A'", true, bag.contains("A"));
- assertEquals("Bag does not have at least 1 'B'", false, bag.contains("B"));
+ assertTrue("Bag has at least 1 'A'", bag.contains("A"));
+ assertFalse("Bag does not have at least 1 'B'", bag.contains("B"));
bag.add((T) "B"); // bag 2A,1B
- assertEquals("Bag has at least 1 'A'", true, bag.contains("A"));
- assertEquals("Bag has at least 1 'B'", true, bag.contains("B"));
+ assertTrue("Bag has at least 1 'A'", bag.contains("A"));
+ assertTrue("Bag has at least 1 'B'", bag.contains("B"));
}
@SuppressWarnings("unchecked")
@@ -258,39 +259,39 @@ public abstract class AbstractBagTest<T> extends AbstractCollectionTest<T> {
known1A1B.add("A");
known1A1B.add("B");
- assertEquals("Bag containsAll of empty", true, bag.containsAll(known));
- assertEquals("Bag does not containsAll of 1 'A'", false, bag.containsAll(known1A));
- assertEquals("Bag does not containsAll of 2 'A'", false, bag.containsAll(known2A));
- assertEquals("Bag does not containsAll of 1 'B'", false, bag.containsAll(known1B));
- assertEquals("Bag does not containsAll of 1 'A' 1 'B'", false, bag.containsAll(known1A1B));
+ assertTrue("Bag containsAll of empty", bag.containsAll(known));
+ assertFalse("Bag does not containsAll of 1 'A'", bag.containsAll(known1A));
+ assertFalse("Bag does not containsAll of 2 'A'", bag.containsAll(known2A));
+ assertFalse("Bag does not containsAll of 1 'B'", bag.containsAll(known1B));
+ assertFalse("Bag does not containsAll of 1 'A' 1 'B'", bag.containsAll(known1A1B));
bag.add((T) "A"); // bag 1A
- assertEquals("Bag containsAll of empty", true, bag.containsAll(known));
- assertEquals("Bag containsAll of 1 'A'", true, bag.containsAll(known1A));
- assertEquals("Bag does not containsAll of 2 'A'", false, bag.containsAll(known2A));
- assertEquals("Bag does not containsAll of 1 'B'", false, bag.containsAll(known1B));
- assertEquals("Bag does not containsAll of 1 'A' 1 'B'", false, bag.containsAll(known1A1B));
+ assertTrue("Bag containsAll of empty", bag.containsAll(known));
+ assertTrue("Bag containsAll of 1 'A'", bag.containsAll(known1A));
+ assertFalse("Bag does not containsAll of 2 'A'", bag.containsAll(known2A));
+ assertFalse("Bag does not containsAll of 1 'B'", bag.containsAll(known1B));
+ assertFalse("Bag does not containsAll of 1 'A' 1 'B'", bag.containsAll(known1A1B));
bag.add((T) "A"); // bag 2A
- assertEquals("Bag containsAll of empty", true, bag.containsAll(known));
- assertEquals("Bag containsAll of 1 'A'", true, bag.containsAll(known1A));
- assertEquals("Bag containsAll of 2 'A'", true, bag.containsAll(known2A));
- assertEquals("Bag does not containsAll of 1 'B'", false, bag.containsAll(known1B));
- assertEquals("Bag does not containsAll of 1 'A' 1 'B'", false, bag.containsAll(known1A1B));
+ assertTrue("Bag containsAll of empty", bag.containsAll(known));
+ assertTrue("Bag containsAll of 1 'A'", bag.containsAll(known1A));
+ assertTrue("Bag containsAll of 2 'A'", bag.containsAll(known2A));
+ assertFalse("Bag does not containsAll of 1 'B'", bag.containsAll(known1B));
+ assertFalse("Bag does not containsAll of 1 'A' 1 'B'", bag.containsAll(known1A1B));
bag.add((T) "A"); // bag 3A
- assertEquals("Bag containsAll of empty", true, bag.containsAll(known));
- assertEquals("Bag containsAll of 1 'A'", true, bag.containsAll(known1A));
- assertEquals("Bag containsAll of 2 'A'", true, bag.containsAll(known2A));
- assertEquals("Bag does not containsAll of 1 'B'", false, bag.containsAll(known1B));
- assertEquals("Bag does not containsAll of 1 'A' 1 'B'", false, bag.containsAll(known1A1B));
+ assertTrue("Bag containsAll of empty", bag.containsAll(known));
+ assertTrue("Bag containsAll of 1 'A'", bag.containsAll(known1A));
+ assertTrue("Bag containsAll of 2 'A'", bag.containsAll(known2A));
+ assertFalse("Bag does not containsAll of 1 'B'", bag.containsAll(known1B));
+ assertFalse("Bag does not containsAll of 1 'A' 1 'B'", bag.containsAll(known1A1B));
bag.add((T) "B"); // bag 3A1B
- assertEquals("Bag containsAll of empty", true, bag.containsAll(known));
- assertEquals("Bag containsAll of 1 'A'", true, bag.containsAll(known1A));
- assertEquals("Bag containsAll of 2 'A'", true, bag.containsAll(known2A));
- assertEquals("Bag containsAll of 1 'B'", true, bag.containsAll(known1B));
- assertEquals("Bag containsAll of 1 'A' 1 'B'", true, bag.containsAll(known1A1B));
+ assertTrue("Bag containsAll of empty", bag.containsAll(known));
+ assertTrue("Bag containsAll of 1 'A'", bag.containsAll(known1A));
+ assertTrue("Bag containsAll of 2 'A'", bag.containsAll(known2A));
+ assertTrue("Bag containsAll of 1 'B'", bag.containsAll(known1B));
+ assertTrue("Bag containsAll of 1 'A' 1 'B'", bag.containsAll(known1A1B));
}
@SuppressWarnings("unchecked")
@@ -452,18 +453,18 @@ public abstract class AbstractBagTest<T> extends AbstractCollectionTest<T> {
assertEquals(2, bag.size());
final Iterator<T> it = bag.iterator();
assertEquals("A", it.next());
- assertEquals(true, it.hasNext());
+ assertTrue(it.hasNext());
it.remove();
assertEquals(1, bag.size());
- assertEquals(true, it.hasNext());
+ assertTrue(it.hasNext());
assertEquals("A", it.next());
- assertEquals(false, it.hasNext());
+ assertFalse(it.hasNext());
it.remove();
assertEquals(0, bag.size());
- assertEquals(false, it.hasNext());
+ assertFalse(it.hasNext());
final Iterator<T> it2 = bag.iterator();
- assertEquals(false, it2.hasNext());
+ assertFalse(it2.hasNext());
}
@SuppressWarnings("unchecked")
@@ -523,11 +524,11 @@ public abstract class AbstractBagTest<T> extends AbstractCollectionTest<T> {
final Bag<T> bag = makeObject();
final Bag<T> bag2 = makeObject();
- assertEquals(true, bag.equals(bag2));
+ assertEquals(bag, bag2);
bag.add((T) "A");
- assertEquals(false, bag.equals(bag2));
+ assertNotEquals(bag, bag2);
bag2.add((T) "A");
- assertEquals(true, bag.equals(bag2));
+ assertEquals(bag, bag2);
bag.add((T) "A");
bag.add((T) "B");
bag.add((T) "B");
@@ -536,7 +537,7 @@ public abstract class AbstractBagTest<T> extends AbstractCollectionTest<T> {
bag2.add((T) "B");
bag2.add((T) "B");
bag2.add((T) "C");
- assertEquals(true, bag.equals(bag2));
+ assertEquals(bag, bag2);
}
@SuppressWarnings("unchecked")
@@ -547,11 +548,11 @@ public abstract class AbstractBagTest<T> extends AbstractCollectionTest<T> {
final Bag<T> bag = makeObject();
final Bag<T> bag2 = new HashBag<>();
- assertEquals(true, bag.equals(bag2));
+ assertEquals(bag, bag2);
bag.add((T) "A");
- assertEquals(false, bag.equals(bag2));
+ assertNotEquals(bag, bag2);
bag2.add((T) "A");
- assertEquals(true, bag.equals(bag2));
+ assertEquals(bag, bag2);
bag.add((T) "A");
bag.add((T) "B");
bag.add((T) "B");
@@ -560,7 +561,7 @@ public abstract class AbstractBagTest<T> extends AbstractCollectionTest<T> {
bag2.add((T) "B");
bag2.add((T) "B");
bag2.add((T) "C");
- assertEquals(true, bag.equals(bag2));
+ assertEquals(bag, bag2);
}
@SuppressWarnings("unchecked")
@@ -684,7 +685,7 @@ public abstract class AbstractBagTest<T> extends AbstractCollectionTest<T> {
final Bag<T> bag = makeObject();
if (bag instanceof Serializable && !skipSerializedCanonicalTests() && isTestSerialization()) {
final Bag<?> bag2 = (Bag<?>) readExternalFormFromDisk(getCanonicalEmptyCollectionName(bag));
- assertTrue("Bag is empty", bag2.size() == 0);
+ assertTrue("Bag is empty", bag2.isEmpty());
assertEquals(bag, bag2);
}
}
diff --git a/src/test/java/org/apache/commons/collections4/bag/CollectionBagTest.java b/src/test/java/org/apache/commons/collections4/bag/CollectionBagTest.java
index e1135f6..53baa37 100644
--- a/src/test/java/org/apache/commons/collections4/bag/CollectionBagTest.java
+++ b/src/test/java/org/apache/commons/collections4/bag/CollectionBagTest.java
@@ -96,7 +96,7 @@ public class CollectionBagTest<T> extends AbstractCollectionTest<T> {
final Bag<T> bag = makeObject();
if (bag instanceof Serializable && !skipSerializedCanonicalTests() && isTestSerialization()) {
final Bag<?> bag2 = (Bag<?>) readExternalFormFromDisk(getCanonicalEmptyCollectionName(bag));
- assertTrue("Bag is empty", bag2.size() == 0);
+ assertTrue("Bag is empty", bag2.isEmpty());
assertEquals(bag, bag2);
}
}
diff --git a/src/test/java/org/apache/commons/collections4/bag/CollectionSortedBagTest.java b/src/test/java/org/apache/commons/collections4/bag/CollectionSortedBagTest.java
index 4c21dbc..1cb9f6c 100644
--- a/src/test/java/org/apache/commons/collections4/bag/CollectionSortedBagTest.java
+++ b/src/test/java/org/apache/commons/collections4/bag/CollectionSortedBagTest.java
@@ -136,7 +136,7 @@ public class CollectionSortedBagTest<T> extends AbstractCollectionTest<T> {
final Bag<T> bag = makeObject();
if (bag instanceof Serializable && !skipSerializedCanonicalTests() && isTestSerialization()) {
final Bag<?> bag2 = (Bag<?>) readExternalFormFromDisk(getCanonicalEmptyCollectionName(bag));
- assertTrue("Bag is empty", bag2.size() == 0);
+ assertEquals("Bag is empty", 0, bag2.size());
assertEquals(bag, bag2);
}
}
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 4a1f3a9..0aed058 100644
--- a/src/test/java/org/apache/commons/collections4/bag/PredicatedBagTest.java
+++ b/src/test/java/org/apache/commons/collections4/bag/PredicatedBagTest.java
@@ -72,28 +72,26 @@ public class PredicatedBagTest<T> extends AbstractBagTest<T> {
for (int i = 0; i < els.length; i++) {
bag.add(els[i]);
assertEquals(i + 1, bag.size());
- assertEquals(true, bag.contains(els[i]));
+ assertTrue(bag.contains(els[i]));
}
- Set<T> set = ((PredicatedBag<T>) bag).uniqueSet();
+ Set<T> set = bag.uniqueSet();
assertTrue("Unique set contains the first element", set.contains(els[0]));
- assertEquals(true, bag.remove(els[0]));
- set = ((PredicatedBag<T>) bag).uniqueSet();
- assertTrue("Unique set now does not contain the first element",
- !set.contains(els[0]));
+ assertTrue(bag.remove(els[0]));
+ set = bag.uniqueSet();
+ assertFalse("Unique set now does not contain the first element", set.contains(els[0]));
}
@SuppressWarnings("unchecked")
public void testIllegalAdd() {
final Bag<T> bag = makeTestBag();
- final Integer i = Integer.valueOf(3);
+ final Integer i = 3;
try {
bag.add((T) i);
fail("Integer should fail string predicate.");
} catch (final IllegalArgumentException e) {
// expected
}
- assertTrue("Collection shouldn't contain illegal element",
- !bag.contains(i));
+ assertFalse("Collection shouldn't contain illegal element", bag.contains(i));
}
@SuppressWarnings("unchecked")
@@ -101,7 +99,7 @@ public class PredicatedBagTest<T> extends AbstractBagTest<T> {
final HashBag<Object> elements = new HashBag<>();
elements.add("one");
elements.add("two");
- elements.add(Integer.valueOf(3));
+ elements.add(3);
elements.add("four");
try {
decorateBag((HashBag<T>) elements, stringPredicate());
diff --git a/src/test/java/org/apache/commons/collections4/bag/PredicatedSortedBagTest.java b/src/test/java/org/apache/commons/collections4/bag/PredicatedSortedBagTest.java
index 4989189..ae1e160 100644
--- a/src/test/java/org/apache/commons/collections4/bag/PredicatedSortedBagTest.java
+++ b/src/test/java/org/apache/commons/collections4/bag/PredicatedSortedBagTest.java
@@ -91,7 +91,7 @@ public class PredicatedSortedBagTest<T> extends AbstractSortedBagTest<T> {
assertEquals("first element", bag.first(), one);
assertEquals("last element", bag.last(), two);
final Comparator<? super T> c = bag.comparator();
- assertTrue("natural order, so comparator should be null", c == null);
+ assertNull("natural order, so comparator should be null", c);
}
@Override
diff --git a/src/test/java/org/apache/commons/collections4/bag/TransformedBagTest.java b/src/test/java/org/apache/commons/collections4/bag/TransformedBagTest.java
index adafe88..36a6eb9 100644
--- a/src/test/java/org/apache/commons/collections4/bag/TransformedBagTest.java
+++ b/src/test/java/org/apache/commons/collections4/bag/TransformedBagTest.java
@@ -53,17 +53,17 @@ public class TransformedBagTest<T> extends AbstractBagTest<T> {
//T had better be Object!
final Bag<T> bag = TransformedBag.transformingBag(new HashBag<T>(),
(Transformer<T, T>) TransformedCollectionTest.STRING_TO_INTEGER_TRANSFORMER);
- assertEquals(0, bag.size());
+ assertTrue(bag.isEmpty());
final Object[] els = new Object[] {"1", "3", "5", "7", "2", "4", "6"};
for (int i = 0; i < els.length; i++) {
bag.add((T) els[i]);
assertEquals(i + 1, bag.size());
- assertEquals(true, bag.contains(Integer.valueOf((String) els[i])));
- assertEquals(false, bag.contains(els[i]));
+ assertTrue(bag.contains(Integer.valueOf((String) els[i])));
+ assertFalse(bag.contains(els[i]));
}
- assertEquals(false, bag.remove(els[0]));
- assertEquals(true, bag.remove(Integer.valueOf((String) els[0])));
+ assertFalse(bag.remove(els[0]));
+ assertTrue(bag.remove(Integer.valueOf((String) els[0])));
}
@SuppressWarnings("unchecked")
@@ -77,12 +77,12 @@ public class TransformedBagTest<T> extends AbstractBagTest<T> {
(Transformer<T, T>) TransformedCollectionTest.STRING_TO_INTEGER_TRANSFORMER);
assertEquals(els.length, bag.size());
for (final Object el : els) {
- assertEquals(true, bag.contains(Integer.valueOf((String) el)));
- assertEquals(false, bag.contains(el));
+ assertTrue(bag.contains(Integer.valueOf((String) el)));
+ assertFalse(bag.contains(el));
}
- assertEquals(false, bag.remove(els[0]));
- assertEquals(true, bag.remove(Integer.valueOf((String) els[0])));
+ assertFalse(bag.remove(els[0]));
+ assertTrue(bag.remove(Integer.valueOf((String) els[0])));
}
@Override
diff --git a/src/test/java/org/apache/commons/collections4/bag/TransformedSortedBagTest.java b/src/test/java/org/apache/commons/collections4/bag/TransformedSortedBagTest.java
index 65c1426..1d8d2ec 100644
--- a/src/test/java/org/apache/commons/collections4/bag/TransformedSortedBagTest.java
+++ b/src/test/java/org/apache/commons/collections4/bag/TransformedSortedBagTest.java
@@ -55,10 +55,10 @@ public class TransformedSortedBagTest<T> extends AbstractSortedBagTest<T> {
for (int i = 0; i < els.length; i++) {
bag.add((T) els[i]);
assertEquals(i + 1, bag.size());
- assertEquals(true, bag.contains(Integer.valueOf((String) els[i])));
+ assertTrue(bag.contains(Integer.valueOf((String) els[i])));
}
- assertEquals(true, bag.remove(Integer.valueOf((String) els[0])));
+ assertTrue(bag.remove(Integer.valueOf((String) els[0])));
}
@@ -71,10 +71,10 @@ public class TransformedSortedBagTest<T> extends AbstractSortedBagTest<T> {
final SortedBag<T> bag = TransformedSortedBag.transformedSortedBag(originalBag, (Transformer<T, T>) TransformedCollectionTest.STRING_TO_INTEGER_TRANSFORMER);
assertEquals(els.length, bag.size());
for (final Object el : els) {
- assertEquals(true, bag.contains(Integer.valueOf((String) el)));
+ assertTrue(bag.contains(Integer.valueOf((String) el)));
}
- assertEquals(true, bag.remove(Integer.valueOf((String) els[0])));
+ assertTrue(bag.remove(Integer.valueOf((String) els[0])));
}
@Override
diff --git a/src/test/java/org/apache/commons/collections4/bidimap/AbstractBidiMapTest.java b/src/test/java/org/apache/commons/collections4/bidimap/AbstractBidiMapTest.java
index 5d9a001..2e50270 100644
--- a/src/test/java/org/apache/commons/collections4/bidimap/AbstractBidiMapTest.java
+++ b/src/test/java/org/apache/commons/collections4/bidimap/AbstractBidiMapTest.java
@@ -132,10 +132,10 @@ public abstract class AbstractBidiMapTest<K, V> extends AbstractIterableMapTest<
final Set<V> keys2 = map2.keySet();
final Collection<V> values1 = map1.values();
final Collection<K> values2 = map2.values();
- assertEquals(true, keys1.containsAll(values2));
- assertEquals(true, values2.containsAll(keys1));
- assertEquals(true, values1.containsAll(keys2));
- assertEquals(true, keys2.containsAll(values1));
+ assertTrue(keys1.containsAll(values2));
+ assertTrue(values2.containsAll(keys1));
+ assertTrue(values1.containsAll(keys2));
+ assertTrue(keys2.containsAll(values1));
}
// testGetKey
@@ -254,18 +254,18 @@ public abstract class AbstractBidiMapTest<K, V> extends AbstractIterableMapTest<
removeValue(makeFullMap(), getSampleValues()[0]);
removeValue(makeFullMap().inverseBidiMap(), getSampleKeys()[0]);
- assertEquals(null, makeFullMap().removeValue("NotPresent"));
+ assertNull(makeFullMap().removeValue("NotPresent"));
}
private void remove(final BidiMap<?, ?> map, final Object key) {
final Object value = map.remove(key);
- assertTrue("Key was not removed.", !map.containsKey(key));
+ assertFalse("Key was not removed.", map.containsKey(key));
assertNull("Value was not removed.", map.getKey(value));
}
private void removeValue(final BidiMap<?, ?> map, final Object value) {
final Object key = map.removeValue(value);
- assertTrue("Key was not removed.", !map.containsKey(key));
+ assertFalse("Key was not removed.", map.containsKey(key));
assertNull("Value was not removed.", map.getKey(value));
}
@@ -274,13 +274,13 @@ public abstract class AbstractBidiMapTest<K, V> extends AbstractIterableMapTest<
resetFull();
final Iterator<K> keys = map.keySet().iterator();
final Iterator<V> values = map.values().iterator();
- for (; keys.hasNext() && values.hasNext();) {
+ while (keys.hasNext() && values.hasNext()) {
final K key = keys.next();
final V value = values.next();
assertSame(map.get(key), value);
}
- assertEquals(false, keys.hasNext());
- assertEquals(false, values.hasNext());
+ assertFalse(keys.hasNext());
+ assertFalse(values.hasNext());
}
//-----------------------------------------------------------------------
@@ -296,15 +296,11 @@ public abstract class AbstractBidiMapTest<K, V> extends AbstractIterableMapTest<
private void removeByKeySet(final BidiMap<?, ?> map, final Object key, final Object value) {
map.keySet().remove(key);
- assertTrue("Key was not removed.", !map.containsKey(key));
- assertTrue("Value was not removed.", !map.containsValue(value));
+ assertFalse("Key was not removed.", map.containsKey(key));
+ assertFalse("Value was not removed.", map.containsValue(value));
- assertTrue(
- "Key was not removed from inverse map.",
- !map.inverseBidiMap().containsValue(key));
- assertTrue(
- "Value was not removed from inverse map.",
- !map.inverseBidiMap().containsKey(value));
+ assertFalse("Key was not removed from inverse map.", map.inverseBidiMap().containsValue(key));
+ assertFalse("Value was not removed from inverse map.", map.inverseBidiMap().containsKey(value));
}
//-----------------------------------------------------------------------
@@ -322,15 +318,11 @@ public abstract class AbstractBidiMapTest<K, V> extends AbstractIterableMapTest<
temp.put(key, value);
map.entrySet().remove(temp.entrySet().iterator().next());
- assertTrue("Key was not removed.", !map.containsKey(key));
- assertTrue("Value was not removed.", !map.containsValue(value));
+ assertFalse("Key was not removed.", map.containsKey(key));
+ assertFalse("Value was not removed.", map.containsValue(value));
- assertTrue(
- "Key was not removed from inverse map.",
- !map.inverseBidiMap().containsValue(key));
- assertTrue(
- "Value was not removed from inverse map.",
- !map.inverseBidiMap().containsKey(value));
+ assertFalse("Key was not removed from inverse map.", map.inverseBidiMap().containsValue(key));
+ assertFalse("Value was not removed from inverse map.", map.inverseBidiMap().containsKey(value));
}
/**
@@ -394,11 +386,11 @@ public abstract class AbstractBidiMapTest<K, V> extends AbstractIterableMapTest<
entryConfirmed2.setValue(newValue1);
AbstractBidiMapTest.this.getConfirmed().remove(key1);
assertEquals(newValue1, entry2.getValue());
- assertEquals(true, AbstractBidiMapTest.this.getMap().containsKey(entry2.getKey()));
- assertEquals(true, AbstractBidiMapTest.this.getMap().containsValue(newValue1));
+ assertTrue(AbstractBidiMapTest.this.getMap().containsKey(entry2.getKey()));
+ assertTrue(AbstractBidiMapTest.this.getMap().containsValue(newValue1));
assertEquals(newValue1, AbstractBidiMapTest.this.getMap().get(entry2.getKey()));
- assertEquals(false, AbstractBidiMapTest.this.getMap().containsKey(key1));
- assertEquals(false, AbstractBidiMapTest.this.getMap().containsValue(newValue2));
+ assertFalse(AbstractBidiMapTest.this.getMap().containsKey(key1));
+ assertFalse(AbstractBidiMapTest.this.getMap().containsValue(newValue2));
TestBidiMapEntrySet.this.verify();
// check for ConcurrentModification
@@ -541,7 +533,7 @@ public abstract class AbstractBidiMapTest<K, V> extends AbstractIterableMapTest<
resetFull();
final BidiMap<K, V> bidi = getMap();
final MapIterator<K, V> it = bidi.mapIterator();
- assertEquals(true, it.hasNext());
+ assertTrue(it.hasNext());
final K key1 = it.next();
if (!isSetValueSupported()) {
@@ -557,8 +549,8 @@ public abstract class AbstractBidiMapTest<K, V> extends AbstractIterableMapTest<
confirmed.put(key1, newValue1);
assertSame(key1, it.getKey());
assertSame(newValue1, it.getValue());
- assertEquals(true, bidi.containsKey(key1));
- assertEquals(true, bidi.containsValue(newValue1));
+ assertTrue(bidi.containsKey(key1));
+ assertTrue(bidi.containsValue(newValue1));
assertEquals(newValue1, bidi.get(key1));
verify();
@@ -566,8 +558,8 @@ public abstract class AbstractBidiMapTest<K, V> extends AbstractIterableMapTest<
confirmed.put(key1, newValue1);
assertSame(key1, it.getKey());
assertSame(newValue1, it.getValue());
- assertEquals(true, bidi.containsKey(key1));
- assertEquals(true, bidi.containsValue(newValue1));
+ assertTrue(bidi.containsKey(key1));
+ assertTrue(bidi.containsValue(newValue1));
assertEquals(newValue1, bidi.get(key1));
verify();
@@ -576,8 +568,8 @@ public abstract class AbstractBidiMapTest<K, V> extends AbstractIterableMapTest<
confirmed.put(key2, newValue2);
assertSame(key2, it.getKey());
assertSame(newValue2, it.getValue());
- assertEquals(true, bidi.containsKey(key2));
- assertEquals(true, bidi.containsValue(newValue2));
+ assertTrue(bidi.containsKey(key2));
+ assertTrue(bidi.containsValue(newValue2));
assertEquals(newValue2, bidi.get(key2));
verify();
@@ -592,11 +584,11 @@ public abstract class AbstractBidiMapTest<K, V> extends AbstractIterableMapTest<
confirmed.put(key2, newValue1);
AbstractBidiMapTest.this.getConfirmed().remove(key1);
assertEquals(newValue1, it.getValue());
- assertEquals(true, bidi.containsKey(it.getKey()));
- assertEquals(true, bidi.containsValue(newValue1));
+ assertTrue(bidi.containsKey(it.getKey()));
+ assertTrue(bidi.containsValue(newValue1));
assertEquals(newValue1, bidi.get(it.getKey()));
- assertEquals(false, bidi.containsKey(key1));
- assertEquals(false, bidi.containsValue(newValue2));
+ assertFalse(bidi.containsKey(key1));
+ assertFalse(bidi.containsValue(newValue2));
verify();
// check for ConcurrentModification
diff --git a/src/test/java/org/apache/commons/collections4/bidimap/AbstractSortedBidiMapTest.java b/src/test/java/org/apache/commons/collections4/bidimap/AbstractSortedBidiMapTest.java
index 1fa7153..6a9a619 100644
--- a/src/test/java/org/apache/commons/collections4/bidimap/AbstractSortedBidiMapTest.java
+++ b/src/test/java/org/apache/commons/collections4/bidimap/AbstractSortedBidiMapTest.java
@@ -53,7 +53,7 @@ public abstract class AbstractSortedBidiMapTest<K extends Comparable<K>, V exten
sortedValues.addAll(map.values());
sortedValues = Collections.unmodifiableList(sortedValues);
- sortedNewValues.addAll(this.<V>getAsList(getNewSampleValues()));
+ sortedNewValues.addAll(getAsList(getNewSampleValues()));
}
// public AbstractTestSortedBidiMap() {
@@ -116,14 +116,14 @@ public abstract class AbstractSortedBidiMapTest<K extends Comparable<K>, V exten
final SortedMap<K, V> head = sm.headMap(toKey);
assertEquals(1, head.size());
- assertEquals(true, sm.containsKey(first));
- assertEquals(true, head.containsKey(first));
- assertEquals(true, sm.containsValue(firstValue));
- assertEquals(true, head.containsValue(firstValue));
- assertEquals(true, sm.containsKey(second));
- assertEquals(false, head.containsKey(second));
- assertEquals(true, sm.containsValue(secondValue));
- assertEquals(false, head.containsValue(secondValue));
+ assertTrue(sm.containsKey(first));
+ assertTrue(head.containsKey(first));
+ assertTrue(sm.containsValue(firstValue));
+ assertTrue(head.containsValue(firstValue));
+ assertTrue(sm.containsKey(second));
+ assertFalse(head.containsKey(second));
+ assertTrue(sm.containsValue(secondValue));
+ assertFalse(head.containsValue(secondValue));
}
//-----------------------------------------------------------------------
@@ -151,26 +151,26 @@ public abstract class AbstractSortedBidiMapTest<K extends Comparable<K>, V exten
assertEquals(size - 2, sm.size());
assertEquals(size - 2, sm.inverseBidiMap().size());
- assertEquals(false, sm.containsKey(first));
- assertEquals(false, sm.containsValue(firstValue));
- assertEquals(false, sm.inverseBidiMap().containsKey(firstValue));
- assertEquals(false, sm.inverseBidiMap().containsValue(first));
- assertEquals(false, sub.containsKey(first));
- assertEquals(false, sub.containsValue(firstValue));
-
- assertEquals(false, sm.containsKey(second));
- assertEquals(false, sm.containsValue(secondValue));
- assertEquals(false, sm.inverseBidiMap().containsKey(secondValue));
- assertEquals(false, sm.inverseBidiMap().containsValue(second));
- assertEquals(false, sub.containsKey(second));
- assertEquals(false, sub.containsValue(secondValue));
-
- assertEquals(true, sm.containsKey(toKey));
- assertEquals(true, sm.containsValue(toKeyValue));
- assertEquals(true, sm.inverseBidiMap().containsKey(toKeyValue));
- assertEquals(true, sm.inverseBidiMap().containsValue(toKey));
- assertEquals(false, sub.containsKey(toKey));
- assertEquals(false, sub.containsValue(toKeyValue));
+ assertFalse(sm.containsKey(first));
+ assertFalse(sm.containsValue(firstValue));
+ assertFalse(sm.inverseBidiMap().containsKey(firstValue));
+ assertFalse(sm.inverseBidiMap().containsValue(first));
+ assertFalse(sub.containsKey(first));
+ assertFalse(sub.containsValue(firstValue));
+
+ assertFalse(sm.containsKey(second));
+ assertFalse(sm.containsValue(secondValue));
+ assertFalse(sm.inverseBidiMap().containsKey(secondValue));
+ assertFalse(sm.inverseBidiMap().containsValue(second));
+ assertFalse(sub.containsKey(second));
+ assertFalse(sub.containsValue(secondValue));
+
+ assertTrue(sm.containsKey(toKey));
+ assertTrue(sm.containsValue(toKeyValue));
+ assertTrue(sm.inverseBidiMap().containsKey(toKeyValue));
+ assertTrue(sm.inverseBidiMap().containsValue(toKey));
+ assertFalse(sub.containsKey(toKey));
+ assertFalse(sub.containsValue(toKeyValue));
}
//-----------------------------------------------------------------------
@@ -189,32 +189,32 @@ public abstract class AbstractSortedBidiMapTest<K extends Comparable<K>, V exten
final int size = sm.size();
final SortedMap<K, V> sub = sm.headMap(toKey);
assertEquals(2, sub.size());
- assertEquals(true, sm.containsKey(first));
- assertEquals(true, sub.containsKey(first));
- assertEquals(true, sm.containsKey(second));
- assertEquals(true, sub.containsKey(second));
+ assertTrue(sm.containsKey(first));
+ assertTrue(sub.containsKey(first));
+ assertTrue(sm.containsKey(second));
+ assertTrue(sub.containsKey(second));
final V firstValue = sub.remove(first);
assertEquals(1, sub.size());
assertEquals(size - 1, sm.size());
assertEquals(size - 1, sm.inverseBidiMap().size());
- assertEquals(false, sm.containsKey(first));
- assertEquals(false, sm.containsValue(firstValue));
- assertEquals(false, sm.inverseBidiMap().containsKey(firstValue));
- assertEquals(false, sm.inverseBidiMap().containsValue(first));
- assertEquals(false, sub.containsKey(first));
- assertEquals(false, sub.containsValue(firstValue));
+ assertFalse(sm.containsKey(first));
+ assertFalse(sm.containsValue(firstValue));
+ assertFalse(sm.inverseBidiMap().containsKey(firstValue));
+ assertFalse(sm.inverseBidiMap().containsValue(first));
+ assertFalse(sub.containsKey(first));
+ assertFalse(sub.containsValue(firstValue));
final V secondValue = sub.remove(second);
assertEquals(0, sub.size());
assertEquals(size - 2, sm.size());
assertEquals(size - 2, sm.inverseBidiMap().size());
- assertEquals(false, sm.containsKey(second));
- assertEquals(false, sm.containsValue(secondValue));
- assertEquals(false, sm.inverseBidiMap().containsKey(secondValue));
- assertEquals(false, sm.inverseBidiMap().containsValue(second));
- assertEquals(false, sub.containsKey(second));
- assertEquals(false, sub.containsValue(secondValue));
+ assertFalse(sm.containsKey(second));
+ assertFalse(sm.containsValue(secondValue));
+ assertFalse(sm.inverseBidiMap().containsKey(secondValue));
+ assertFalse(sm.inverseBidiMap().containsValue(second));
+ assertFalse(sub.containsKey(second));
+ assertFalse(sub.containsValue(secondValue));
}
//-----------------------------------------------------------------------
@@ -239,36 +239,36 @@ public abstract class AbstractSortedBidiMapTest<K extends Comparable<K>, V exten
final Iterator<Map.Entry<K, V>> it2 = set.iterator();
final Map.Entry<K, V> firstEntry = cloneMapEntry(it2.next());
final Map.Entry<K, V> secondEntry = cloneMapEntry(it2.next());
- assertEquals(true, sm.containsKey(first));
- assertEquals(true, sub.containsKey(first));
- assertEquals(true, set.contains(firstEntry));
- assertEquals(true, sm.containsKey(second));
- assertEquals(true, sub.containsKey(second));
- assertEquals(true, set.contains(secondEntry));
+ assertTrue(sm.containsKey(first));
+ assertTrue(sub.containsKey(first));
+ assertTrue(set.contains(firstEntry));
+ assertTrue(sm.containsKey(second));
+ assertTrue(sub.containsKey(second));
+ assertTrue(set.contains(secondEntry));
set.remove(firstEntry);
assertEquals(1, sub.size());
assertEquals(size - 1, sm.size());
assertEquals(size - 1, sm.inverseBidiMap().size());
- assertEquals(false, sm.containsKey(firstEntry.getKey()));
- assertEquals(false, sm.containsValue(firstEntry.getValue()));
- assertEquals(false, sm.inverseBidiMap().containsKey(firstEntry.getValue()));
- assertEquals(false, sm.inverseBidiMap().containsValue(firstEntry.getKey()));
- assertEquals(false, sub.containsKey(firstEntry.getKey()));
- assertEquals(false, sub.containsValue(firstEntry.getValue()));
- assertEquals(false, set.contains(firstEntry));
+ assertFalse(sm.containsKey(firstEntry.getKey()));
+ assertFalse(sm.containsValue(firstEntry.getValue()));
+ assertFalse(sm.inverseBidiMap().containsKey(firstEntry.getValue()));
+ assertFalse(sm.inverseBidiMap().containsValue(firstEntry.getKey()));
+ assertFalse(sub.containsKey(firstEntry.getKey()));
+ assertFalse(sub.containsValue(firstEntry.getValue()));
+ assertFalse(set.contains(firstEntry));
set.remove(secondEntry);
assertEquals(0, sub.size());
assertEquals(size - 2, sm.size());
assertEquals(size - 2, sm.inverseBidiMap().size());
- assertEquals(false, sm.containsKey(secondEntry.getKey()));
- assertEquals(false, sm.containsValue(secondEntry.getValue()));
- assertEquals(false, sm.inverseBidiMap().containsKey(secondEntry.getValue()));
- assertEquals(false, sm.inverseBidiMap().containsValue(secondEntry.getKey()));
- assertEquals(false, sub.containsKey(secondEntry.getKey()));
- assertEquals(false, sub.containsValue(secondEntry.getValue()));
- assertEquals(false, set.contains(secondEntry));
+ assertFalse(sm.containsKey(secondEntry.getKey()));
+ assertFalse(sm.containsValue(secondEntry.getValue()));
+ assertFalse(sm.inverseBidiMap().containsKey(secondEntry.getValue()));
+ assertFalse(sm.inverseBidiMap().containsValue(secondEntry.getKey()));
+ assertFalse(sub.containsKey(secondEntry.getKey()));
+ assertFalse(sub.containsValue(secondEntry.getValue()));
+ assertFalse(set.contains(secondEntry));
}
//-----------------------------------------------------------------------
@@ -286,18 +286,18 @@ public abstract class AbstractSortedBidiMapTest<K extends Comparable<K>, V exten
final SortedMap<K, V> sub = sm.tailMap(fromKey);
assertEquals(sm.size() - 1, sub.size());
- assertEquals(true, sm.containsKey(first));
- assertEquals(false, sub.containsKey(first));
- assertEquals(true, sm.containsValue(firstValue));
- assertEquals(false, sub.containsValue(firstValue));
- assertEquals(true, sm.containsKey(fromKey));
- assertEquals(true, sub.containsKey(fromKey));
- assertEquals(true, sm.containsValue(fromKeyValue));
- assertEquals(true, sub.containsValue(fromKeyValue));
- assertEquals(true, sm.containsKey(second));
- assertEquals(true, sub.containsKey(second));
- assertEquals(true, sm.containsValue(secondValue));
- assertEquals(true, sub.containsValue(secondValue));
+ assertTrue(sm.containsKey(first));
+ assertFalse(sub.containsKey(first));
+ assertTrue(sm.containsValue(firstValue));
+ assertFalse(sub.containsValue(firstValue));
+ assertTrue(sm.containsKey(fromKey));
+ assertTrue(sub.containsKey(fromKey));
+ assertTrue(sm.containsValue(fromKeyValue));
+ assertTrue(sub.containsValue(fromKeyValue));
+ assertTrue(sm.containsKey(second));
+ assertTrue(sub.containsKey(second));
+ assertTrue(sm.containsValue(secondValue));
+ assertTrue(sub.containsValue(secondValue));
}
//-----------------------------------------------------------------------
@@ -327,26 +327,26 @@ public abstract class AbstractSortedBidiMapTest<K extends Comparable<K>, V exten
assertEquals(3, sm.size());
assertEquals(3, sm.inverseBidiMap().size());
- assertEquals(true, sm.containsKey(first));
- assertEquals(true, sm.containsValue(firstValue));
- assertEquals(true, sm.inverseBidiMap().containsKey(firstValue));
- assertEquals(true, sm.inverseBidiMap().containsValue(first));
- assertEquals(false, sub.containsKey(first));
- assertEquals(false, sub.containsValue(firstValue));
-
- assertEquals(false, sm.containsKey(fromKey));
- assertEquals(false, sm.containsValue(fromKeyValue));
- assertEquals(false, sm.inverseBidiMap().containsKey(fromKeyValue));
- assertEquals(false, sm.inverseBidiMap().containsValue(fromKey));
- assertEquals(false, sub.containsKey(fromKey));
- assertEquals(false, sub.containsValue(fromKeyValue));
-
- assertEquals(false, sm.containsKey(second));
- assertEquals(false, sm.containsValue(secondValue));
- assertEquals(false, sm.inverseBidiMap().containsKey(secondValue));
- assertEquals(false, sm.inverseBidiMap().containsValue(second));
- assertEquals(false, sub.containsKey(second));
- assertEquals(false, sub.containsValue(secondValue));
+ assertTrue(sm.containsKey(first));
+ assertTrue(sm.containsValue(firstValue));
+ assertTrue(sm.inverseBidiMap().containsKey(firstValue));
+ assertTrue(sm.inverseBidiMap().containsValue(first));
+ assertFalse(sub.containsKey(first));
+ assertFalse(sub.containsValue(firstValue));
+
+ assertFalse(sm.containsKey(fromKey));
+ assertFalse(sm.containsValue(fromKeyValue));
+ assertFalse(sm.inverseBidiMap().containsKey(fromKeyValue));
+ assertFalse(sm.inverseBidiMap().containsValue(fromKey));
+ assertFalse(sub.containsKey(fromKey));
+ assertFalse(sub.containsValue(fromKeyValue));
+
+ assertFalse(sm.containsKey(second));
+ assertFalse(sm.containsValue(secondValue));
+ assertFalse(sm.inverseBidiMap().containsKey(secondValue));
+ assertFalse(sm.inverseBidiMap().containsValue(second));
+ assertFalse(sub.containsKey(second));
+ assertFalse(sub.containsValue(secondValue));
}
//-----------------------------------------------------------------------
@@ -366,32 +366,32 @@ public abstract class AbstractSortedBidiMapTest<K extends Comparable<K>, V exten
final int size = sm.size();
final SortedMap<K, V> sub = sm.tailMap(fromKey);
- assertEquals(true, sm.containsKey(first));
- assertEquals(true, sub.containsKey(first));
- assertEquals(true, sm.containsKey(second));
- assertEquals(true, sub.containsKey(second));
+ assertTrue(sm.containsKey(first));
+ assertTrue(sub.containsKey(first));
+ assertTrue(sm.containsKey(second));
+ assertTrue(sub.containsKey(second));
final Object firstValue = sub.remove(first);
assertEquals(size - 3, sub.size());
assertEquals(size - 1, sm.size());
assertEquals(size - 1, sm.inverseBidiMap().size());
- assertEquals(false, sm.containsKey(first));
- assertEquals(false, sm.containsValue(firstValue));
- assertEquals(false, sm.inverseBidiMap().containsKey(firstValue));
- assertEquals(false, sm.inverseBidiMap().containsValue(first));
- assertEquals(false, sub.containsKey(first));
- assertEquals(false, sub.containsValue(firstValue));
+ assertFalse(sm.containsKey(first));
+ assertFalse(sm.containsValue(firstValue));
+ assertFalse(sm.inverseBidiMap().containsKey(firstValue));
+ assertFalse(sm.inverseBidiMap().containsValue(first));
+ assertFalse(sub.containsKey(first));
+ assertFalse(sub.containsValue(firstValue));
final Object secondValue = sub.remove(second);
assertEquals(size - 4, sub.size());
assertEquals(size - 2, sm.size());
assertEquals(size - 2, sm.inverseBidiMap().size());
- assertEquals(false, sm.containsKey(second));
- assertEquals(false, sm.containsValue(secondValue));
- assertEquals(false, sm.inverseBidiMap().containsKey(secondValue));
- assertEquals(false, sm.inverseBidiMap().containsValue(second));
- assertEquals(false, sub.containsKey(second));
- assertEquals(false, sub.containsValue(secondValue));
+ assertFalse(sm.containsKey(second));
+ assertFalse(sm.containsValue(secondValue));
+ assertFalse(sm.inverseBidiMap().containsKey(secondValue));
+ assertFalse(sm.inverseBidiMap().containsValue(second));
+ assertFalse(sub.containsKey(second));
+ assertFalse(sub.containsValue(secondValue));
}
//-----------------------------------------------------------------------
@@ -416,36 +416,36 @@ public abstract class AbstractSortedBidiMapTest<K extends Comparable<K>, V exten
it2.next();
final Map.Entry<K, V> firstEntry = cloneMapEntry(it2.next());
final Map.Entry<K, V> secondEntry = cloneMapEntry(it2.next());
- assertEquals(true, sm.containsKey(first));
- assertEquals(true, sub.containsKey(first));
- assertEquals(true, set.contains(firstEntry));
- assertEquals(true, sm.containsKey(second));
- assertEquals(true, sub.containsKey(second));
- assertEquals(true, set.contains(secondEntry));
+ assertTrue(sm.containsKey(first));
+ assertTrue(sub.containsKey(first));
+ assertTrue(set.contains(firstEntry));
+ assertTrue(sm.containsKey(second));
+ assertTrue(sub.containsKey(second));
+ assertTrue(set.contains(secondEntry));
set.remove(firstEntry);
assertEquals(size - 3, sub.size());
assertEquals(size - 1, sm.size());
assertEquals(size - 1, sm.inverseBidiMap().size());
- assertEquals(false, sm.containsKey(firstEntry.getKey()));
- assertEquals(false, sm.containsValue(firstEntry.getValue()));
- assertEquals(false, sm.inverseBidiMap().containsKey(firstEntry.getValue()));
- assertEquals(false, sm.inverseBidiMap().containsValue(firstEntry.getKey()));
- assertEquals(false, sub.containsKey(firstEntry.getKey()));
- assertEquals(false, sub.containsValue(firstEntry.getValue()));
- assertEquals(false, set.contains(firstEntry));
+ assertFalse(sm.containsKey(firstEntry.getKey()));
+ assertFalse(sm.containsValue(firstEntry.getValue()));
+ assertFalse(sm.inverseBidiMap().containsKey(firstEntry.getValue()));
+ assertFalse(sm.inverseBidiMap().containsValue(firstEntry.getKey()));
+ assertFalse(sub.containsKey(firstEntry.getKey()));
+ assertFalse(sub.containsValue(firstEntry.getValue()));
+ assertFalse(set.contains(firstEntry));
set.remove(secondEntry);
assertEquals(size - 4, sub.size());
assertEquals(size - 2, sm.size());
assertEquals(size - 2, sm.inverseBidiMap().size());
- assertEquals(false, sm.containsKey(secondEntry.getKey()));
- assertEquals(false, sm.containsValue(secondEntry.getValue()));
- assertEquals(false, sm.inverseBidiMap().containsKey(secondEntry.getValue()));
- assertEquals(false, sm.inverseBidiMap().containsValue(secondEntry.getKey()));
- assertEquals(false, sub.containsKey(secondEntry.getKey()));
- assertEquals(false, sub.containsValue(secondEntry.getValue()));
- assertEquals(false, set.contains(secondEntry));
+ assertFalse(sm.containsKey(secondEntry.getKey()));
+ assertFalse(sm.containsValue(secondEntry.getValue()));
+ assertFalse(sm.inverseBidiMap().containsKey(secondEntry.getValue()));
+ assertFalse(sm.inverseBidiMap().containsValue(secondEntry.getKey()));
+ assertFalse(sub.containsKey(secondEntry.getKey()));
+ assertFalse(sub.containsValue(secondEntry.getValue()));
+ assertFalse(set.contains(secondEntry));
}
//-----------------------------------------------------------------------
@@ -466,22 +466,22 @@ public abstract class AbstractSortedBidiMapTest<K extends Comparable<K>, V exten
final SortedMap<K, V> sub = sm.subMap(fromKey, toKey);
assertEquals(2, sub.size());
- assertEquals(true, sm.containsKey(first));
- assertEquals(false, sub.containsKey(first));
- assertEquals(true, sm.containsValue(firstValue));
- assertEquals(false, sub.containsValue(firstValue));
- assertEquals(true, sm.containsKey(fromKey));
- assertEquals(true, sub.containsKey(fromKey));
- assertEquals(true, sm.containsValue(fromKeyValue));
- assertEquals(true, sub.containsValue(fromKeyValue));
- assertEquals(true, sm.containsKey(second));
- assertEquals(true, sub.containsKey(second));
- assertEquals(true, sm.containsValue(secondValue));
- assertEquals(true, sub.containsValue(secondValue));
- assertEquals(true, sm.containsKey(third));
- assertEquals(false, sub.containsKey(third));
- assertEquals(true, sm.containsValue(thirdValue));
- assertEquals(false, sub.containsValue(thirdValue));
+ assertTrue(sm.containsKey(first));
+ assertFalse(sub.containsKey(first));
+ assertTrue(sm.containsValue(firstValue));
+ assertFalse(sub.containsValue(firstValue));
+ assertTrue(sm.containsKey(fromKey));
+ assertTrue(sub.containsKey(fromKey));
+ assertTrue(sm.containsValue(fromKeyValue));
+ assertTrue(sub.containsValue(fromKeyValue));
+ assertTrue(sm.containsKey(second));
+ assertTrue(sub.containsKey(second));
+ assertTrue(sm.containsValue(secondValue));
+ assertTrue(sub.containsValue(secondValue));
+ assertTrue(sm.containsKey(third));
+ assertFalse(sub.containsKey(third));
+ assertTrue(sm.containsValue(thirdValue));
+ assertFalse(sub.containsValue(thirdValue));
}
//-----------------------------------------------------------------------
@@ -512,33 +512,33 @@ public abstract class AbstractSortedBidiMapTest<K extends Comparable<K>, V exten
assertEquals(size - 3, sm.size());
assertEquals(size - 3, sm.inverseBidiMap().size());
- assertEquals(false, sm.containsKey(fromKey));
- assertEquals(false, sm.containsValue(fromKeyValue));
- assertEquals(false, sm.inverseBidiMap().containsKey(fromKeyValue));
- assertEquals(false, sm.inverseBidiMap().containsValue(fromKey));
- assertEquals(false, sub.containsKey(fromKey));
- assertEquals(false, sub.containsValue(fromKeyValue));
-
- assertEquals(false, sm.containsKey(first));
- assertEquals(false, sm.containsValue(firstValue));
- assertEquals(false, sm.inverseBidiMap().containsKey(firstValue));
- assertEquals(false, sm.inverseBidiMap().containsValue(first));
- assertEquals(false, sub.containsKey(first));
- assertEquals(false, sub.containsValue(firstValue));
-
- assertEquals(false, sm.containsKey(second));
- assertEquals(false, sm.containsValue(secondValue));
- assertEquals(false, sm.inverseBidiMap().containsKey(secondValue));
- assertEquals(false, sm.inverseBidiMap().containsValue(second));
- assertEquals(false, sub.containsKey(second));
- assertEquals(false, sub.containsValue(secondValue));
-
- assertEquals(true, sm.containsKey(toKey));
- assertEquals(true, sm.containsValue(toKeyValue));
- assertEquals(true, sm.inverseBidiMap().containsKey(toKeyValue));
- assertEquals(true, sm.inverseBidiMap().containsValue(toKey));
- assertEquals(false, sub.containsKey(toKey));
- assertEquals(false, sub.containsValue(toKeyValue));
+ assertFalse(sm.containsKey(fromKey));
+ assertFalse(sm.containsValue(fromKeyValue));
+ assertFalse(sm.inverseBidiMap().containsKey(fromKeyValue));
+ assertFalse(sm.inverseBidiMap().containsValue(fromKey));
+ assertFalse(sub.containsKey(fromKey));
+ assertFalse(sub.containsValue(fromKeyValue));
+
+ assertFalse(sm.containsKey(first));
+ assertFalse(sm.containsValue(firstValue));
+ assertFalse(sm.inverseBidiMap().containsKey(firstValue));
+ assertFalse(sm.inverseBidiMap().containsValue(first));
+ assertFalse(sub.containsKey(first));
+ assertFalse(sub.containsValue(firstValue));
+
+ assertFalse(sm.containsKey(second));
+ assertFalse(sm.containsValue(secondValue));
+ assertFalse(sm.inverseBidiMap().containsKey(secondValue));
+ assertFalse(sm.inverseBidiMap().containsValue(second));
+ assertFalse(sub.containsKey(second));
+ assertFalse(sub.containsValue(secondValue));
+
+ assertTrue(sm.containsKey(toKey));
+ assertTrue(sm.containsValue(toKeyValue));
+ assertTrue(sm.inverseBidiMap().containsKey(toKeyValue));
+ assertTrue(sm.inverseBidiMap().containsValue(toKey));
+ assertFalse(sub.containsKey(toKey));
+ assertFalse(sub.containsValue(toKeyValue));
}
//-----------------------------------------------------------------------
@@ -559,32 +559,32 @@ public abstract class AbstractSortedBidiMapTest<K extends Comparable<K>, V exten
final int size = sm.size();
final SortedMap<K, V> sub = sm.subMap(fromKey, toKey);
- assertEquals(true, sm.containsKey(first));
- assertEquals(true, sub.containsKey(first));
- assertEquals(true, sm.containsKey(second));
- assertEquals(true, sub.containsKey(second));
+ assertTrue(sm.containsKey(first));
+ assertTrue(sub.containsKey(first));
+ assertTrue(sm.containsKey(second));
+ assertTrue(sub.containsKey(second));
final V firstValue = sub.remove(first);
assertEquals(2, sub.size());
assertEquals(size - 1, sm.size());
assertEquals(size - 1, sm.inverseBidiMap().size());
- assertEquals(false, sm.containsKey(first));
- assertEquals(false, sm.containsValue(firstValue));
- assertEquals(false, sm.inverseBidiMap().containsKey(firstValue));
- assertEquals(false, sm.inverseBidiMap().containsValue(first));
- assertEquals(false, sub.containsKey(first));
- assertEquals(false, sub.containsValue(firstValue));
+ assertFalse(sm.containsKey(first));
+ assertFalse(sm.containsValue(firstValue));
+ assertFalse(sm.inverseBidiMap().containsKey(firstValue));
+ assertFalse(sm.inverseBidiMap().containsValue(first));
+ assertFalse(sub.containsKey(first));
+ assertFalse(sub.containsValue(firstValue));
final V secondValue = sub.remove(second);
assertEquals(1, sub.size());
assertEquals(size - 2, sm.size());
assertEquals(size - 2, sm.inverseBidiMap().size());
- assertEquals(false, sm.containsKey(second));
- assertEquals(false, sm.containsValue(secondValue));
- assertEquals(false, sm.inverseBidiMap().containsKey(secondValue));
- assertEquals(false, sm.inverseBidiMap().containsValue(second));
- assertEquals(false, sub.containsKey(second));
- assertEquals(false, sub.containsValue(secondValue));
+ assertFalse(sm.containsKey(second));
+ assertFalse(sm.containsValue(secondValue));
+ assertFalse(sm.inverseBidiMap().containsKey(secondValue));
+ assertFalse(sm.inverseBidiMap().containsValue(second));
+ assertFalse(sub.containsKey(second));
+ assertFalse(sub.containsValue(secondValue));
}
//-----------------------------------------------------------------------
@@ -611,36 +611,36 @@ public abstract class AbstractSortedBidiMapTest<K extends Comparable<K>, V exten
it2.next();
final Map.Entry<K, V> firstEntry = cloneMapEntry(it2.next());
final Map.Entry<K, V> secondEntry = cloneMapEntry(it2.next());
- assertEquals(true, sm.containsKey(first));
- assertEquals(true, sub.containsKey(first));
- assertEquals(true, set.contains(firstEntry));
- assertEquals(true, sm.containsKey(second));
- assertEquals(true, sub.containsKey(second));
- assertEquals(true, set.contains(secondEntry));
+ assertTrue(sm.containsKey(first));
+ assertTrue(sub.containsKey(first));
+ assertTrue(set.contains(firstEntry));
+ assertTrue(sm.containsKey(second));
+ assertTrue(sub.containsKey(second));
+ assertTrue(set.contains(secondEntry));
set.remove(firstEntry);
assertEquals(2, sub.size());
assertEquals(size - 1, sm.size());
assertEquals(size - 1, sm.inverseBidiMap().size());
- assertEquals(false, sm.containsKey(firstEntry.getKey()));
- assertEquals(false, sm.containsValue(firstEntry.getValue()));
- assertEquals(false, sm.inverseBidiMap().containsKey(firstEntry.getValue()));
- assertEquals(false, sm.inverseBidiMap().containsValue(firstEntry.getKey()));
- assertEquals(false, sub.containsKey(firstEntry.getKey()));
- assertEquals(false, sub.containsValue(firstEntry.getValue()));
- assertEquals(false, set.contains(firstEntry));
+ assertFalse(sm.containsKey(firstEntry.getKey()));
+ assertFalse(sm.containsValue(firstEntry.getValue()));
+ assertFalse(sm.inverseBidiMap().containsKey(firstEntry.getValue()));
+ assertFalse(sm.inverseBidiMap().containsValue(firstEntry.getKey()));
+ assertFalse(sub.containsKey(firstEntry.getKey()));
+ assertFalse(sub.containsValue(firstEntry.getValue()));
+ assertFalse(set.contains(firstEntry));
set.remove(secondEntry);
assertEquals(1, sub.size());
assertEquals(size - 2, sm.size());
assertEquals(size - 2, sm.inverseBidiMap().size());
- assertEquals(false, sm.containsKey(secondEntry.getKey()));
- assertEquals(false, sm.containsValue(secondEntry.getValue()));
- assertEquals(false, sm.inverseBidiMap().containsKey(secondEntry.getValue()));
- assertEquals(false, sm.inverseBidiMap().containsValue(secondEntry.getKey()));
- assertEquals(false, sub.containsKey(secondEntry.getKey()));
- assertEquals(false, sub.containsValue(secondEntry.getValue()));
- assertEquals(false, set.contains(secondEntry));
+ assertFalse(sm.containsKey(secondEntry.getKey()));
+ assertFalse(sm.containsValue(secondEntry.getValue()));
+ assertFalse(sm.inverseBidiMap().containsKey(secondEntry.getValue()));
+ assertFalse(sm.inverseBidiMap().containsValue(secondEntry.getKey()));
+ assertFalse(sub.containsKey(secondEntry.getKey()));
+ assertFalse(sub.containsValue(secondEntry.getValue()));
+ assertFalse(set.contains(secondEntry));
}
//-----------------------------------------------------------------------
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 c402c43..2ef8725 100644
--- a/src/test/java/org/apache/commons/collections4/collection/AbstractCollectionTest.java
+++ b/src/test/java/org/apache/commons/collections4/collection/AbstractCollectionTest.java
@@ -33,6 +33,7 @@ import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
+import java.util.Objects;
import java.util.function.Predicate;
import org.apache.commons.collections4.AbstractObjectTest;
@@ -282,7 +283,7 @@ public abstract class AbstractCollectionTest<E> extends AbstractObjectTest {
// skip values already matched
continue;
}
- if (o == confirmedValues[i] || o != null && o.equals(confirmedValues[i])) {
+ if (Objects.equals(o, confirmedValues[i])) {
// values matched
matched[i] = true;
match = true;
@@ -647,16 +648,14 @@ public abstract class AbstractCollectionTest<E> extends AbstractObjectTest {
resetEmpty();
elements = getFullElements();
for (int i = 0; i < elements.length; i++) {
- assertTrue("Empty collection shouldn't contain element[" + i + "]",
- !getCollection().contains(elements[i]));
+ assertFalse("Empty collection shouldn't contain element[" + i + "]", getCollection().contains(elements[i]));
}
// make sure calls to "contains" don't change anything
verify();
elements = getOtherElements();
for (int i = 0; i < elements.length; i++) {
- assertTrue("Empty collection shouldn't contain element[" + i + "]",
- !getCollection().contains(elements[i]));
+ assertFalse("Empty collection shouldn't contain element[" + i + "]", getCollection().contains(elements[i]));
}
// make sure calls to "contains" don't change anything
verify();
@@ -673,8 +672,7 @@ public abstract class AbstractCollectionTest<E> extends AbstractObjectTest {
resetFull();
elements = getOtherElements();
for (final Object element : elements) {
- assertTrue("Full collection shouldn't contain element",
- !getCollection().contains(element));
+ assertFalse("Full collection shouldn't contain element", getCollection().contains(element));
}
}
@@ -687,14 +685,13 @@ public abstract class AbstractCollectionTest<E> extends AbstractObjectTest {
assertTrue("Every Collection should contain all elements of an " +
"empty Collection.", getCollection().containsAll(col));
col.addAll(Arrays.asList(getOtherElements()));
- assertTrue("Empty Collection shouldn't contain all elements of " +
- "a non-empty Collection.", !getCollection().containsAll(col));
+ assertFalse("Empty Collection shouldn't contain all elements of " +
+ "a non-empty Collection.", getCollection().containsAll(col));
// make sure calls to "containsAll" don't change anything
verify();
resetFull();
- assertTrue("Full collection shouldn't contain other elements",
- !getCollection().containsAll(col));
+ assertFalse("Full collection shouldn't contain other elements", getCollection().containsAll(col));
col.clear();
col.addAll(Arrays.asList(getFullElements()));
@@ -728,12 +725,12 @@ public abstract class AbstractCollectionTest<E> extends AbstractObjectTest {
*/
public void testCollectionIsEmpty() {
resetEmpty();
- assertEquals("New Collection should be empty.", true, getCollection().isEmpty());
+ assertTrue("New Collection should be empty.", getCollection().isEmpty());
// make sure calls to "isEmpty() don't change anything
verify();
resetFull();
- assertEquals("Full collection shouldn't be empty", false, getCollection().isEmpty());
+ assertFalse("Full collection shouldn't be empty", getCollection().isEmpty());
// make sure calls to "isEmpty() don't change anything
verify();
}
@@ -744,7 +741,7 @@ public abstract class AbstractCollectionTest<E> extends AbstractObjectTest {
public void testCollectionIterator() {
resetEmpty();
Iterator<E> it1 = getCollection().iterator();
- assertEquals("Iterator for empty Collection shouldn't have next.", false, it1.hasNext());
+ assertFalse("Iterator for empty Collection shouldn't have next.", it1.hasNext());
try {
it1.next();
fail("Iterator at end of Collection should throw "
@@ -761,7 +758,7 @@ public abstract class AbstractCollectionTest<E> extends AbstractObjectTest {
assertTrue("Iterator for full collection should haveNext", it1.hasNext());
it1.next();
}
- assertTrue("Iterator should be finished", !it1.hasNext());
+ assertFalse("Iterator should be finished", it1.hasNext());
final ArrayList<E> list = new ArrayList<>();
it1 = getCollection().iterator();
@@ -871,7 +868,7 @@ public abstract class AbstractCollectionTest<E> extends AbstractObjectTest {
resetFull();
for (final E element : other) {
- assertTrue("Shouldn't remove nonexistent other element", !getCollection().remove(element));
+ assertFalse("Shouldn't remove nonexistent other element", getCollection().remove(element));
verify();
}
@@ -916,12 +913,10 @@ public abstract class AbstractCollectionTest<E> extends AbstractObjectTest {
verify();
resetFull();
- assertTrue("Full collection removeAll should return false for empty input",
- !getCollection().removeAll(Collections.EMPTY_SET));
+ assertFalse("Full collection removeAll should return false for empty input", getCollection().removeAll(Collections.EMPTY_SET));
verify();
- assertTrue("Full collection removeAll should return false for other elements",
- !getCollection().removeAll(Arrays.asList(getOtherElements())));
+ assertFalse("Full collection removeAll should return false for other elements", getCollection().removeAll(Arrays.asList(getOtherElements())));
verify();
assertTrue("Full collection removeAll should return true for full elements",
@@ -941,7 +936,7 @@ public abstract class AbstractCollectionTest<E> extends AbstractObjectTest {
assertTrue("Collection should shrink after removeAll", getCollection().size() < size);
for (final E element : all) {
- assertTrue("Collection shouldn't contain removed element", !getCollection().contains(element));
+ assertFalse("Collection shouldn't contain removed element", getCollection().contains(element));
}
}
@@ -955,17 +950,14 @@ public abstract class AbstractCollectionTest<E> extends AbstractObjectTest {
}
resetEmpty();
- assertTrue("Empty collection removeIf should return false for a predicate that returns only false",
- !getCollection().removeIf(e -> false));
+ assertFalse("Empty collection removeIf should return false for a predicate that returns only false", getCollection().removeIf(e -> false));
verify();
- assertTrue("Empty collection removeIf should return false for a predicate that returns only true",
- !getCollection().removeIf(e -> true));
+ assertFalse("Empty collection removeIf should return false for a predicate that returns only true", getCollection().removeIf(e -> true));
verify();
resetFull();
- assertTrue("Full collection removeIf should return false for a predicate that returns only false",
- !getCollection().removeIf(e -> false));
+ assertFalse("Full collection removeIf should return false for a predicate that returns only false", getCollection().removeIf(e -> false));
verify();
assertTrue("Full collection removeIf should return true for a predicate that returns only true",
@@ -988,8 +980,8 @@ public abstract class AbstractCollectionTest<E> extends AbstractObjectTest {
getConfirmed().removeIf(filter);
verify();
- assertTrue("Collection should shrink after removeIf", getCollection().size() == size - targetCount);
- assertTrue("Collection shouldn't contain removed element", !getCollection().contains(target));
+ assertEquals("Collection should shrink after removeIf", getCollection().size(), size - targetCount);
+ assertFalse("Collection shouldn't contain removed element", getCollection().contains(target));
}
/**
@@ -1004,11 +996,10 @@ public abstract class AbstractCollectionTest<E> extends AbstractObjectTest {
final List<E> elements = Arrays.asList(getFullElements());
final List<E> other = Arrays.asList(getOtherElements());
- assertTrue("Empty retainAll() should return false",
- !getCollection().retainAll(Collections.EMPTY_SET));
+ assertFalse("Empty retainAll() should return false", getCollection().retainAll(Collections.EMPTY_SET));
verify();
- assertTrue("Empty retainAll() should return false", !getCollection().retainAll(elements));
+ assertFalse("Empty retainAll() should return false", getCollection().retainAll(elements));
verify();
resetFull();
@@ -1024,8 +1015,7 @@ public abstract class AbstractCollectionTest<E> extends AbstractObjectTest {
resetFull();
int size = getCollection().size();
- assertTrue("Collection shouldn't change from retainAll elements",
- !getCollection().retainAll(elements));
+ assertFalse("Collection shouldn't change from retainAll elements", getCollection().retainAll(elements));
verify();
assertEquals("Collection size shouldn't change", size, getCollection().size());
@@ -1047,8 +1037,8 @@ public abstract class AbstractCollectionTest<E> extends AbstractObjectTest {
resetFull();
final HashSet<E> set = new HashSet<>(elements);
size = getCollection().size();
- assertTrue("Collection shouldn't change from retainAll without " +
- "duplicate elements", !getCollection().retainAll(set));
+ assertFalse("Collection shouldn't change from retainAll without " +
+ "duplicate elements", getCollection().retainAll(set));
verify();
assertEquals("Collection size didn't change from nonduplicate " +
"retainAll", size, getCollection().size());
@@ -1093,8 +1083,7 @@ public abstract class AbstractCollectionTest<E> extends AbstractObjectTest {
if (matched[j]) {
continue;
}
- if (array[i] == confirmedArray[j]
- || array[i] != null && array[i].equals(confirmedArray[j])) {
+ if (Objects.equals(array[i], confirmedArray[j])) {
matched[j] = true;
match = true;
break;
@@ -1106,8 +1095,7 @@ public abstract class AbstractCollectionTest<E> extends AbstractObjectTest {
}
}
for (final boolean element : matched) {
- assertEquals("Collection should return all its elements in " + "toArray", true,
- element);
+ assertTrue("Collection should return all its elements in " + "toArray", element);
}
}
@@ -1174,10 +1162,10 @@ public abstract class AbstractCollectionTest<E> extends AbstractObjectTest {
*/
public void testCollectionToString() {
resetEmpty();
- assertTrue("toString shouldn't return null", getCollection().toString() != null);
+ assertNotNull("toString shouldn't return null", getCollection().toString());
resetFull();
- assertTrue("toString shouldn't return null", getCollection().toString() != null);
+ assertNotNull("toString shouldn't return null", getCollection().toString());
}
/**
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 b1f2984..a0e8a06 100644
--- a/src/test/java/org/apache/commons/collections4/collection/CompositeCollectionTest.java
+++ b/src/test/java/org/apache/commons/collections4/collection/CompositeCollectionTest.java
@@ -81,9 +81,7 @@ public class CompositeCollectionTest<E> extends AbstractCollectionTest<E> {
*/
@Override
public Collection<E> makeConfirmedFullCollection() {
- final Collection<E> collection = new HashSet<>();
- collection.addAll(Arrays.asList(getFullElements()));
- return collection;
+ return new HashSet<>(Arrays.asList(getFullElements()));
}
/**
* Full collection consists of 4 collections, each with one element
@@ -188,8 +186,7 @@ public class CompositeCollectionTest<E> extends AbstractCollectionTest<E> {
one.add((E) "1");
two.add((E) "2");
c.addComposited(one, two);
- final Collection<E> toCollection = new HashSet<>();
- toCollection.addAll(c);
+ final Collection<E> toCollection = new HashSet<>(c);
assertTrue(toCollection.containsAll(c));
assertEquals(c.size(), toCollection.size());
}
@@ -281,7 +278,7 @@ public class CompositeCollectionTest<E> extends AbstractCollectionTest<E> {
c.addComposited(empty);
assertTrue(c.isEmpty());
empty.add((E) "a");
- assertTrue(!c.isEmpty());
+ assertFalse(c.isEmpty());
}
@SuppressWarnings("unchecked")
@@ -297,8 +294,8 @@ public class CompositeCollectionTest<E> extends AbstractCollectionTest<E> {
assertTrue(one.contains(next));
next = i.next();
i.remove();
- assertTrue(!c.contains(next));
- assertTrue(!two.contains(next));
+ assertFalse(c.contains(next));
+ assertFalse(two.contains(next));
}
@SuppressWarnings("unchecked")
@@ -322,9 +319,9 @@ public class CompositeCollectionTest<E> extends AbstractCollectionTest<E> {
two.add((E) "1");
c.addComposited(one, two);
c.remove("1");
- assertTrue(!c.contains("1"));
- assertTrue(!one.contains("1"));
- assertTrue(!two.contains("1"));
+ assertFalse(c.contains("1"));
+ assertFalse(one.contains("1"));
+ assertFalse(two.contains("1"));
}
@SuppressWarnings("unchecked")
@@ -341,9 +338,9 @@ public class CompositeCollectionTest<E> extends AbstractCollectionTest<E> {
assertTrue(!one.contains("1"));
assertTrue(!two.contains("1"));
c.removeAll(null);
- assertTrue(!c.contains("1"));
- assertTrue(!one.contains("1"));
- assertTrue(!two.contains("1"));
+ assertFalse(c.contains("1"));
+ assertFalse(one.contains("1"));
+ assertFalse(two.contains("1"));
}
/**
@@ -388,13 +385,13 @@ public class CompositeCollectionTest<E> extends AbstractCollectionTest<E> {
two.add((E) "1");
c.addComposited(one);
c.retainAll(two);
- assertTrue(!c.contains("2"));
- assertTrue(!one.contains("2"));
+ assertFalse(c.contains("2"));
+ assertFalse(one.contains("2"));
assertTrue(c.contains("1"));
assertTrue(one.contains("1"));
c.retainAll(null);
- assertTrue(!c.contains("2"));
- assertTrue(!one.contains("2"));
+ assertFalse(c.contains("2"));
+ assertFalse(one.contains("2"));
assertTrue(c.contains("1"));
assertTrue(one.contains("1"));
}
@@ -419,7 +416,7 @@ public class CompositeCollectionTest<E> extends AbstractCollectionTest<E> {
assertTrue(foo.containsAll(c));
assertEquals(c.size(), foo.size());
one.add((E) "3");
- assertTrue(!foo.containsAll(c));
+ assertFalse(foo.containsAll(c));
}
/**
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 6fe953b..1fdf575 100644
--- a/src/test/java/org/apache/commons/collections4/collection/PredicatedCollectionTest.java
+++ b/src/test/java/org/apache/commons/collections4/collection/PredicatedCollectionTest.java
@@ -62,16 +62,13 @@ public class PredicatedCollectionTest<E> extends AbstractCollectionTest<E> {
@Override
public Collection<E> makeFullCollection() {
- final List<E> list = new ArrayList<>();
- list.addAll(Arrays.asList(getFullElements()));
+ final List<E> list = new ArrayList<>(Arrays.asList(getFullElements()));
return decorateCollection(list, truePredicate);
}
@Override
public Collection<E> makeConfirmedFullCollection() {
- final List<E> list = new ArrayList<>();
- list.addAll(Arrays.asList(getFullElements()));
- return list;
+ return new ArrayList<>(Arrays.asList(getFullElements()));
}
//-----------------------------------------------------------------------
@@ -85,15 +82,14 @@ public class PredicatedCollectionTest<E> extends AbstractCollectionTest<E> {
@SuppressWarnings("unchecked")
public void testIllegalAdd() {
final Collection<E> c = makeTestCollection();
- final Integer i = Integer.valueOf(3);
+ final Integer i = 3;
try {
c.add((E) i);
fail("Integer should fail string predicate.");
} catch (final IllegalArgumentException e) {
// expected
}
- assertTrue("Collection shouldn't contain illegal element",
- !c.contains(i));
+ assertFalse("Collection shouldn't contain illegal element", c.contains(i));
}
@SuppressWarnings("unchecked")
@@ -110,10 +106,10 @@ public class PredicatedCollectionTest<E> extends AbstractCollectionTest<E> {
} catch (final IllegalArgumentException e) {
// expected
}
- assertTrue("Collection shouldn't contain illegal element", !c.contains("one"));
- assertTrue("Collection shouldn't contain illegal element", !c.contains("two"));
- assertTrue("Collection shouldn't contain illegal element", !c.contains(Integer.valueOf(3)));
- assertTrue("Collection shouldn't contain illegal element", !c.contains("four"));
+ assertFalse("Collection shouldn't contain illegal element", c.contains("one"));
+ assertFalse("Collection shouldn't contain illegal element", c.contains("two"));
+ assertFalse("Collection shouldn't contain illegal element", c.contains(3));
+ assertFalse("Collection shouldn't contain illegal element", c.contains("four"));
}
@Override
diff --git a/src/test/java/org/apache/commons/collections4/collection/TransformedCollectionTest.java b/src/test/java/org/apache/commons/collections4/collection/TransformedCollectionTest.java
index cd81550..0898c6a 100644
--- a/src/test/java/org/apache/commons/collections4/collection/TransformedCollectionTest.java
+++ b/src/test/java/org/apache/commons/collections4/collection/TransformedCollectionTest.java
@@ -63,9 +63,7 @@ public class TransformedCollectionTest extends AbstractCollectionTest<Object> {
@Override
public Collection<Object> makeConfirmedFullCollection() {
- final List<Object> list = new ArrayList<>();
- list.addAll(Arrays.asList(getFullElements()));
- return list;
+ return new ArrayList<>(Arrays.asList(getFullElements()));
}
@Override
@@ -75,8 +73,7 @@ public class TransformedCollectionTest extends AbstractCollectionTest<Object> {
@Override
public Collection<Object> makeFullCollection() {
- final List<Object> list = new ArrayList<>();
- list.addAll(Arrays.asList(getFullElements()));
+ final List<Object> list = new ArrayList<>(Arrays.asList(getFullElements()));
return TransformedCollection.transformingCollection(list, NOOP_TRANSFORMER);
}
@@ -99,11 +96,11 @@ public class TransformedCollectionTest extends AbstractCollectionTest<Object> {
for (int i = 0; i < elements.length; i++) {
coll.add(elements[i]);
assertEquals(i + 1, coll.size());
- assertEquals(true, coll.contains(Integer.valueOf((String) elements[i])));
- assertEquals(false, coll.contains(elements[i]));
+ assertTrue(coll.contains(Integer.valueOf((String) elements[i])));
+ assertFalse(coll.contains(elements[i]));
}
- assertEquals(true, coll.remove(Integer.valueOf((String) elements[0])));
+ assertTrue(coll.remove(Integer.valueOf((String) elements[0])));
}
public void testTransformedCollection_decorateTransform() {
@@ -113,12 +110,12 @@ public class TransformedCollectionTest extends AbstractCollectionTest<Object> {
final Collection<Object> collection = TransformedCollection.transformedCollection(originalCollection, TransformedCollectionTest.STRING_TO_INTEGER_TRANSFORMER);
assertEquals(elements.length, collection.size());
for (final Object element : elements) {
- assertEquals(true, collection.contains(Integer.valueOf((String) element)));
- assertEquals(false, collection.contains(element));
+ assertTrue(collection.contains(Integer.valueOf((String) element)));
+ assertFalse(collection.contains(element));
}
- assertEquals(false, collection.remove(elements[0]));
- assertEquals(true, collection.remove(Integer.valueOf((String) elements[0])));
+ assertFalse(collection.remove(elements[0]));
+ assertTrue(collection.remove(Integer.valueOf((String) elements[0])));
}
@Override
diff --git a/src/test/java/org/apache/commons/collections4/comparators/AbstractComparatorTest.java b/src/test/java/org/apache/commons/collections4/comparators/AbstractComparatorTest.java
index 6309927..c58fc61 100644
--- a/src/test/java/org/apache/commons/collections4/comparators/AbstractComparatorTest.java
+++ b/src/test/java/org/apache/commons/collections4/comparators/AbstractComparatorTest.java
@@ -97,7 +97,7 @@ public abstract class AbstractComparatorTest<T> extends AbstractObjectTest {
* Sort the list.
*/
protected void sortObjects(final List<T> list, final Comparator<? super T> comparator) {
- Collections.sort(list, comparator);
+ list.sort(comparator);
}
//-----------------------------------------------------------------------
@@ -111,7 +111,7 @@ public abstract class AbstractComparatorTest<T> extends AbstractObjectTest {
final List<T> list2 = new LinkedList<>();
- assertTrue("Comparator cannot sort empty lists", list2.equals(list));
+ assertEquals("Comparator cannot sort empty lists", list2, list);
}
/**
@@ -127,8 +127,7 @@ public abstract class AbstractComparatorTest<T> extends AbstractObjectTest {
final List<T> orderedList = getComparableObjectsOrdered();
- assertTrue("Comparator did not reorder the List correctly",
- orderedList.equals(randomList));
+ assertEquals("Comparator did not reorder the List correctly", orderedList, randomList);
}
/**
@@ -151,9 +150,7 @@ public abstract class AbstractComparatorTest<T> extends AbstractObjectTest {
}
*/
- assertTrue("Comparator did not reorder the List correctly",
- orderedList.equals(randomList));
-
+ assertEquals("Comparator did not reorder the List correctly", orderedList, randomList);
}
/**
@@ -216,9 +213,7 @@ public abstract class AbstractComparatorTest<T> extends AbstractObjectTest {
final List<T> orderedList = getComparableObjectsOrdered();
- assertTrue("Comparator did not reorder the List correctly",
- orderedList.equals(randomList));
+ assertEquals("Comparator did not reorder the List correctly", orderedList, randomList);
}
}
-
}
diff --git a/src/test/java/org/apache/commons/collections4/comparators/BooleanComparatorTest.java b/src/test/java/org/apache/commons/collections4/comparators/BooleanComparatorTest.java
index 5b5c007..41067b9 100644
--- a/src/test/java/org/apache/commons/collections4/comparators/BooleanComparatorTest.java
+++ b/src/test/java/org/apache/commons/collections4/comparators/BooleanComparatorTest.java
@@ -17,11 +17,14 @@
package org.apache.commons.collections4.comparators;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import org.junit.Test;
+import static org.junit.Assert.assertNotEquals;
+
/**
* Tests for {@link BooleanComparator}.
*
@@ -46,14 +49,8 @@ public class BooleanComparatorTest extends AbstractComparatorTest<Boolean> {
@Override
public List<Boolean> getComparableObjectsOrdered() {
- final List<Boolean> list = new ArrayList<>();
- list.add(new Boolean(false));
- list.add(Boolean.FALSE);
- list.add(new Boolean(false));
- list.add(Boolean.TRUE);
- list.add(new Boolean(true));
- list.add(true);
- return list;
+ return new ArrayList<>(Arrays.asList(Boolean.FALSE, Boolean.FALSE, Boolean.FALSE, Boolean.TRUE, Boolean.TRUE,
+ true));
}
@Override
@@ -95,8 +92,8 @@ public class BooleanComparatorTest extends AbstractComparatorTest<Boolean> {
assertEquals(new BooleanComparator(true), BooleanComparator.getTrueFirstComparator());
assertSame(BooleanComparator.getTrueFirstComparator(), BooleanComparator.booleanComparator(true));
- assertTrue(!new BooleanComparator().equals(new BooleanComparator(true)));
- assertTrue(!new BooleanComparator(true).equals(new BooleanComparator(false)));
+ assertNotEquals(new BooleanComparator(), new BooleanComparator(true));
+ assertNotEquals(new BooleanComparator(true), new BooleanComparator(false));
}
// utilities
diff --git a/src/test/java/org/apache/commons/collections4/comparators/ComparatorChainTest.java b/src/test/java/org/apache/commons/collections4/comparators/ComparatorChainTest.java
index c0b4cf4..9ddc8da 100644
--- a/src/test/java/org/apache/commons/collections4/comparators/ComparatorChainTest.java
+++ b/src/test/java/org/apache/commons/collections4/comparators/ComparatorChainTest.java
@@ -17,6 +17,7 @@
package org.apache.commons.collections4.comparators;
import java.io.Serializable;
+import java.util.Arrays;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
@@ -53,19 +54,19 @@ public class ComparatorChainTest extends AbstractComparatorTest<ComparatorChainT
@Test
public void testNoopComparatorChain() {
final ComparatorChain<Integer> chain = new ComparatorChain<>();
- final Integer i1 = Integer.valueOf(4);
- final Integer i2 = Integer.valueOf(6);
- chain.addComparator(new ComparableComparator<Integer>());
+ final Integer i1 = 4;
+ final Integer i2 = 6;
+ chain.addComparator(new ComparableComparator<>());
final int correctValue = i1.compareTo(i2);
- assertTrue("Comparison returns the right order", chain.compare(i1, i2) == correctValue);
+ assertEquals("Comparison returns the right order", chain.compare(i1, i2), correctValue);
}
@Test
public void testBadNoopComparatorChain() {
final ComparatorChain<Integer> chain = new ComparatorChain<>();
- final Integer i1 = Integer.valueOf(4);
- final Integer i2 = Integer.valueOf(6);
+ final Integer i1 = 4;
+ final Integer i2 = 6;
try {
chain.compare(i1, i2);
fail("An exception should be thrown when a chain contains zero comparators.");
@@ -76,21 +77,21 @@ public class ComparatorChainTest extends AbstractComparatorTest<ComparatorChainT
@Test
public void testListComparatorChain() {
final List<Comparator<Integer>> list = new LinkedList<>();
- list.add(new ComparableComparator<Integer>());
+ list.add(new ComparableComparator<>());
final ComparatorChain<Integer> chain = new ComparatorChain<>(list);
- final Integer i1 = Integer.valueOf(4);
- final Integer i2 = Integer.valueOf(6);
+ final Integer i1 = 4;
+ final Integer i2 = 6;
final int correctValue = i1.compareTo(i2);
- assertTrue("Comparison returns the right order", chain.compare(i1, i2) == correctValue);
+ assertEquals("Comparison returns the right order", chain.compare(i1, i2), correctValue);
}
@Test
public void testBadListComparatorChain() {
final List<Comparator<Integer>> list = new LinkedList<>();
final ComparatorChain<Integer> chain = new ComparatorChain<>(list);
- final Integer i1 = Integer.valueOf(4);
- final Integer i2 = Integer.valueOf(6);
+ final Integer i1 = 4;
+ final Integer i2 = 6;
try {
chain.compare(i1, i2);
fail("An exception should be thrown when a chain contains zero comparators.");
@@ -114,24 +115,18 @@ public class ComparatorChainTest extends AbstractComparatorTest<ComparatorChainT
return 0;
}, true);
- assertTrue(chain.compare(Integer.valueOf(4), Integer.valueOf(5)) > 0);
- assertTrue(chain.compare(Integer.valueOf(5), Integer.valueOf(4)) < 0);
- assertTrue(chain.compare(Integer.valueOf(4), Integer.valueOf(4)) == 0);
+ assertTrue(chain.compare(4, 5) > 0);
+ assertTrue(chain.compare(5, 4) < 0);
+ assertEquals(0, chain.compare(4, 4));
}
@Override
public List<PseudoRow> getComparableObjectsOrdered() {
- final List<PseudoRow> list = new LinkedList<>();
// this is the correct order assuming a
// "0th forward, 1st reverse, 2nd forward" sort
- list.add(new PseudoRow(1, 2, 3));
- list.add(new PseudoRow(2, 3, 5));
- list.add(new PseudoRow(2, 2, 4));
- list.add(new PseudoRow(2, 2, 8));
- list.add(new PseudoRow(3, 1, 0));
- list.add(new PseudoRow(4, 4, 4));
- list.add(new PseudoRow(4, 4, 7));
- return list;
+ return new LinkedList<>(Arrays.asList(new PseudoRow(1, 2, 3), new PseudoRow(2, 3, 5),
+ new PseudoRow(2, 2, 4), new PseudoRow(2, 2, 8), new PseudoRow(3, 1, 0),
+ new PseudoRow(4, 4, 4), new PseudoRow(4, 4, 7)));
}
public static class PseudoRow implements Serializable {
@@ -140,7 +135,7 @@ public class ComparatorChainTest extends AbstractComparatorTest<ComparatorChainT
* Generated serial version ID.
*/
private static final long serialVersionUID = 8085570439751032499L;
- public int cols[] = new int[3];
+ public int[] cols = new int[3];
public PseudoRow(final int col1, final int col2, final int col3) {
cols[0] = col1;
@@ -154,15 +149,7 @@ public class ComparatorChainTest extends AbstractComparatorTest<ComparatorChainT
@Override
public String toString() {
- final StringBuilder buf = new StringBuilder();
- buf.append("[");
- buf.append(cols[0]);
- buf.append(",");
- buf.append(cols[1]);
- buf.append(",");
- buf.append(cols[2]);
- buf.append("]");
- return buf.toString();
+ return "[" + cols[0] + "," + cols[1] + "," + cols[2] + "]";
}
@Override
@@ -172,21 +159,9 @@ public class ComparatorChainTest extends AbstractComparatorTest<ComparatorChainT
}
final PseudoRow row = (PseudoRow) o;
- if (getColumn(0) != row.getColumn(0)) {
- return false;
- }
-
- if (getColumn(1) != row.getColumn(1)) {
- return false;
- }
-
- if (getColumn(2) != row.getColumn(2)) {
- return false;
- }
- return true;
+ return getColumn(0) == row.getColumn(0) && getColumn(1) == row.getColumn(1) && getColumn(2) == row.getColumn(2);
}
-
}
public static class ColumnComparator implements Comparator<PseudoRow>, Serializable {
@@ -200,17 +175,7 @@ public class ComparatorChainTest extends AbstractComparatorTest<ComparatorChainT
@Override
public int compare(final PseudoRow o1, final PseudoRow o2) {
-
- final int col1 = o1.getColumn(colIndex);
- final int col2 = o2.getColumn(colIndex);
-
- if (col1 > col2) {
- return 1;
- }
- if (col1 < col2) {
- return -1;
- }
- return 0;
+ return Integer.compare(o1.getColumn(colIndex), o2.getColumn(colIndex));
}
@Override
diff --git a/src/test/java/org/apache/commons/collections4/comparators/FixedOrderComparatorTest.java b/src/test/java/org/apache/commons/collections4/comparators/FixedOrderComparatorTest.java
index d3fc4ee..97ace60 100644
--- a/src/test/java/org/apache/commons/collections4/comparators/FixedOrderComparatorTest.java
+++ b/src/test/java/org/apache/commons/collections4/comparators/FixedOrderComparatorTest.java
@@ -60,8 +60,7 @@ public class FixedOrderComparatorTest extends AbstractComparatorTest<String> {
@Override
public Comparator<String> makeObject() {
- final FixedOrderComparator<String> comparator = new FixedOrderComparator<>(topCities);
- return comparator;
+ return new FixedOrderComparator<>(topCities);
}
@Override
@@ -141,9 +140,9 @@ public class FixedOrderComparatorTest extends AbstractComparatorTest<String> {
@Test
public void testLock() {
final FixedOrderComparator<String> comparator = new FixedOrderComparator<>(topCities);
- assertEquals(false, comparator.isLocked());
+ assertFalse(comparator.isLocked());
comparator.compare("New York", "Tokyo");
- assertEquals(true, comparator.isLocked());
+ assertTrue(comparator.isLocked());
try {
comparator.add("Minneapolis");
fail("Should have thrown an UnsupportedOperationException");
@@ -225,9 +224,10 @@ public class FixedOrderComparatorTest extends AbstractComparatorTest<String> {
}
// testShuffle
- for (int i = 0; i < keys.length && !isInNewOrder; i++) {
- if ( !orderedObjects[i].equals(keys[i])) {
+ for (int i = 0; i < keys.length; i++) {
+ if (!orderedObjects[i].equals(keys[i])) {
isInNewOrder = true;
+ break;
}
}
}
@@ -240,5 +240,4 @@ public class FixedOrderComparatorTest extends AbstractComparatorTest<String> {
assertEquals(orderedObjects[i], keys[i]);
}
}
-
}
diff --git a/src/test/java/org/apache/commons/collections4/functors/AbstractPredicateTest.java b/src/test/java/org/apache/commons/collections4/functors/AbstractPredicateTest.java
index 3f6614a..9ef75cf 100644
--- a/src/test/java/org/apache/commons/collections4/functors/AbstractPredicateTest.java
+++ b/src/test/java/org/apache/commons/collections4/functors/AbstractPredicateTest.java
@@ -44,11 +44,11 @@ public abstract class AbstractPredicateTest {
*/
protected abstract Predicate<?> generatePredicate();
- protected <T> void assertFalse(final Predicate<T> predicate, final T testObject) {
+ protected <T> void assertPredicateFalse(final Predicate<T> predicate, final T testObject) {
Assert.assertFalse(predicate.evaluate(testObject));
}
- protected <T> void assertTrue(final Predicate<T> predicate, final T testObject) {
+ protected <T> void assertPredicateTrue(final Predicate<T> predicate, final T testObject) {
Assert.assertTrue(predicate.evaluate(testObject));
}
}
diff --git a/src/test/java/org/apache/commons/collections4/functors/ComparatorPredicateTest.java b/src/test/java/org/apache/commons/collections4/functors/ComparatorPredicateTest.java
index 2bdb650..afda1fc 100644
--- a/src/test/java/org/apache/commons/collections4/functors/ComparatorPredicateTest.java
+++ b/src/test/java/org/apache/commons/collections4/functors/ComparatorPredicateTest.java
@@ -36,45 +36,45 @@ public class ComparatorPredicateTest extends AbstractPredicateTest {
public void compareEquals() {
final Integer value = Integer.valueOf(10);
final Predicate<Integer> p = comparatorPredicate(value, new TestComparator<Integer>());
- assertFalse(p, Integer.valueOf(value.intValue() - 1));
- assertTrue(p, Integer.valueOf(value.intValue()));
- assertFalse(p, Integer.valueOf(value.intValue() + 1));
+ assertPredicateFalse(p, Integer.valueOf(value.intValue() - 1));
+ assertPredicateTrue(p, Integer.valueOf(value.intValue()));
+ assertPredicateFalse(p, Integer.valueOf(value.intValue() + 1));
}
@Test
public void compareGreater() {
final Integer value = Integer.valueOf(10);
final Predicate<Integer> p = comparatorPredicate(value, new TestComparator<Integer>(), Criterion.GREATER);
- assertTrue(p, Integer.valueOf(value.intValue() - 1));
- assertFalse(p, Integer.valueOf(value.intValue()));
- assertFalse(p, Integer.valueOf(value.intValue() + 1));
+ assertPredicateTrue(p, Integer.valueOf(value.intValue() - 1));
+ assertPredicateFalse(p, Integer.valueOf(value.intValue()));
+ assertPredicateFalse(p, Integer.valueOf(value.intValue() + 1));
}
@Test
public void compareLess() {
final Integer value = Integer.valueOf(10);
final Predicate<Integer> p = comparatorPredicate(value, new TestComparator<Integer>(), Criterion.LESS);
- assertFalse(p, Integer.valueOf(value.intValue() - 1));
- assertFalse(p, Integer.valueOf(value.intValue()));
- assertTrue(p, Integer.valueOf(value.intValue() + 1));
+ assertPredicateFalse(p, Integer.valueOf(value.intValue() - 1));
+ assertPredicateFalse(p, Integer.valueOf(value.intValue()));
+ assertPredicateTrue(p, Integer.valueOf(value.intValue() + 1));
}
@Test
public void compareGreaterOrEqual() {
final Integer value = Integer.valueOf(10);
final Predicate<Integer> p = comparatorPredicate(value, new TestComparator<Integer>(), Criterion.GREATER_OR_EQUAL);
- assertTrue(p, Integer.valueOf(value.intValue() - 1));
- assertTrue(p, Integer.valueOf(value.intValue()));
- assertFalse(p, Integer.valueOf(value.intValue() + 1));
+ assertPredicateTrue(p, Integer.valueOf(value.intValue() - 1));
+ assertPredicateTrue(p, Integer.valueOf(value.intValue()));
+ assertPredicateFalse(p, Integer.valueOf(value.intValue() + 1));
}
@Test
public void compareLessOrEqual() {
final Integer value = Integer.valueOf(10);
final Predicate<Integer> p = comparatorPredicate(value, new TestComparator<Integer>(), Criterion.LESS_OR_EQUAL);
- assertFalse(p, Integer.valueOf(value.intValue() - 1));
- assertTrue(p, Integer.valueOf(value.intValue()));
- assertTrue(p, Integer.valueOf(value.intValue() + 1));
+ assertPredicateFalse(p, Integer.valueOf(value.intValue() - 1));
+ assertPredicateTrue(p, Integer.valueOf(value.intValue()));
+ assertPredicateTrue(p, Integer.valueOf(value.intValue() + 1));
}
@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 4cc4c91..3ff4861 100644
--- a/src/test/java/org/apache/commons/collections4/functors/EqualPredicateTest.java
+++ b/src/test/java/org/apache/commons/collections4/functors/EqualPredicateTest.java
@@ -41,15 +41,15 @@ public class EqualPredicateTest extends AbstractPredicateTest {
@Test
public void objectFactoryUsesEqualsForTest() throws Exception {
final Predicate<EqualsTestObject> predicate = equalPredicate(FALSE_OBJECT);
- assertFalse(predicate, FALSE_OBJECT);
- assertTrue(equalPredicate(TRUE_OBJECT), TRUE_OBJECT);
+ assertPredicateFalse(predicate, FALSE_OBJECT);
+ assertPredicateTrue(equalPredicate(TRUE_OBJECT), TRUE_OBJECT);
}
@SuppressWarnings("boxing")
@Test
public void testPredicateTypeCanBeSuperClassOfObject() throws Exception {
final Predicate<Number> predicate = equalPredicate((Number) 4);
- assertTrue(predicate, 4);
+ assertPredicateTrue(predicate, 4);
}
public static class EqualsTestObject {
diff --git a/src/test/java/org/apache/commons/collections4/functors/NullPredicateTest.java b/src/test/java/org/apache/commons/collections4/functors/NullPredicateTest.java
index 2df59fc..652f7c8 100644
--- a/src/test/java/org/apache/commons/collections4/functors/NullPredicateTest.java
+++ b/src/test/java/org/apache/commons/collections4/functors/NullPredicateTest.java
@@ -26,13 +26,13 @@ public class NullPredicateTest extends AbstractPredicateTest {
@Test
public void testNullPredicate() {
assertSame(NullPredicate.nullPredicate(), NullPredicate.nullPredicate());
- assertTrue(nullPredicate(), null);
+ assertPredicateTrue(nullPredicate(), null);
}
@Test
public void ensurePredicateCanBeTypedWithoutWarning() throws Exception {
final Predicate<String> predicate = NullPredicate.nullPredicate();
- assertFalse(predicate, cString);
+ assertPredicateFalse(predicate, cString);
}
@Override