Apache/commons-collections
1
0
Fork 0
mirror of https://github.com/apache/commons-collections.git synced 2025-02-10 03:56:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'pr-158'

Browse Source 
This closes #158
This commit is contained in:
Bruno P. Kinoshita 2020-04-19 18:39:21 +12:00
commit 477db84c1f
29 changed files with 752 additions and 867 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

231
src/test/java/org/apache/commons/collections4/CollectionUtilsTest.java
View File

@ -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);
final Integer elta = 17;
final Integer eltb = 17;
// ...which are equal...
assertEquals(elta, eltb);
assertEquals(eltb, elta);
// ...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());

14
src/test/java/org/apache/commons/collections4/ComparatorUtilsTest.java
View File

@ -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);
}
}

9
src/test/java/org/apache/commons/collections4/FactoryUtilsTest.java
View File

@ -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);
}

10
src/test/java/org/apache/commons/collections4/IterableUtilsTest.java
View File

@ -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

30
src/test/java/org/apache/commons/collections4/MultiMapUtilsTest.java
View File

@ -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

277
src/test/java/org/apache/commons/collections4/PredicateUtilsTest.java
View File

@ -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);
assertPredicateFalse(PredicateUtils.anyPredicate(), 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));
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();

28
src/test/java/org/apache/commons/collections4/SetUtilsTest.java
View File

@ -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

61
src/test/java/org/apache/commons/collections4/TransformerUtilsTest.java
View File

@ -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));
}

107
src/test/java/org/apache/commons/collections4/bag/AbstractBagTest.java
View File

@ -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);
}
}

2
src/test/java/org/apache/commons/collections4/bag/CollectionBagTest.java
View File

@ -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);
}
}

2
src/test/java/org/apache/commons/collections4/bag/CollectionSortedBagTest.java
View File

@ -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);
}
}

18
src/test/java/org/apache/commons/collections4/bag/PredicatedBagTest.java
View File

@ -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());

2
src/test/java/org/apache/commons/collections4/bag/PredicatedSortedBagTest.java
View File

@ -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

18
src/test/java/org/apache/commons/collections4/bag/TransformedBagTest.java
View File

@ -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

8
src/test/java/org/apache/commons/collections4/bag/TransformedSortedBagTest.java
View File

@ -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

74
src/test/java/org/apache/commons/collections4/bidimap/AbstractBidiMapTest.java
View File

@ -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

410
src/test/java/org/apache/commons/collections4/bidimap/AbstractSortedBidiMapTest.java
View File

@ -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));
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));
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));
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));
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));
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));
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));
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));
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));
}
//-----------------------------------------------------------------------
@ -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));
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));
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));
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));
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));
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));
}
//-----------------------------------------------------------------------

72
src/test/java/org/apache/commons/collections4/collection/AbstractCollectionTest.java
View File

@ -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());
}
/**

35
src/test/java/org/apache/commons/collections4/collection/CompositeCollectionTest.java
View File

@ -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));
}
/**

20
src/test/java/org/apache/commons/collections4/collection/PredicatedCollectionTest.java
View File

@ -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

21
src/test/java/org/apache/commons/collections4/collection/TransformedCollectionTest.java
View File

@ -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

15
src/test/java/org/apache/commons/collections4/comparators/AbstractComparatorTest.java
View File

@ -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);
}
}
}

17
src/test/java/org/apache/commons/collections4/comparators/BooleanComparatorTest.java
View File

@ -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

81
src/test/java/org/apache/commons/collections4/comparators/ComparatorChainTest.java
View File

@ -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

13
src/test/java/org/apache/commons/collections4/comparators/FixedOrderComparatorTest.java
View File

@ -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]);
}
}
}

4
src/test/java/org/apache/commons/collections4/functors/AbstractPredicateTest.java
View File

@ -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));
}
}

30
src/test/java/org/apache/commons/collections4/functors/ComparatorPredicateTest.java
View File

@ -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

6
src/test/java/org/apache/commons/collections4/functors/EqualPredicateTest.java
View File

@ -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 {

4
src/test/java/org/apache/commons/collections4/functors/NullPredicateTest.java
View File

@ -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