Apache
/
commons-collections
mirror of https://github.com/apache/commons-collections.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fixed checkstyle in tests. 

Changed rules to be more lenient on tests.
This commit is contained in:
Alex Herbert 2020-02-18 23:25:52 +00:00
parent de46979712
commit 9bc4d0bc61
38 changed files with 264 additions and 261 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
pom.xml
View File

@ -605,7 +605,7 @@
<headerLocation>${basedir}/src/conf/license-header.txt</headerLocation>
<suppressionsLocation>${basedir}/src/conf/checkstyle-suppressions.xml</suppressionsLocation>
<enableRulesSummary>false</enableRulesSummary>
<includeTestSourceDirectory>false</includeTestSourceDirectory>
<includeTestSourceDirectory>true</includeTestSourceDirectory>
<resourceExcludes>NOTICE.txt,LICENSE.txt,**/pom.properties,**/test.properties,**/resolver-status.properties</resourceExcludes>
</configuration>
</plugin>

9
src/conf/checkstyle-suppressions.xml
View File

@ -31,4 +31,13 @@
<!-- Ignore missing javadoc param for unsupported method -->
<suppress checks="JavadocMethod" files="FilterListIterator.java" lines="116,166" />
<!-- Be more lenient on tests. -->
<suppress checks="Javadoc" files=".*[/\\]test[/\\].*" />
<suppress checks="MultipleStringLiterals" files=".*[/\\]test[/\\].*" />
<suppress checks="DesignForExtension" files=".*[/\\]test[/\\].*" />
<suppress checks="LineLength" files=".*[/\\]test[/\\].*" />
<suppress checks="IllegalCatch" files=".*[/\\]test[/\\].*" />
<suppress checks="MethodLength" files="(MersenneTwister64|Well44497[ab]|MultiplyWithCarry256)Test" />
<suppress checks="AvoidStarImport" files=".*[/\\]test[/\\].*" />
</suppressions>

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

@ -942,7 +942,7 @@ public class MapUtilsTest extends AbstractAvailableLocalesTest {
assertEquals(5.0, MapUtils.getDoubleValue(in, "noKey", (key)->{
//sometimes the default value need to be calculated,such as System.currentTimeMillis()
return 5.0D;
}),0);
}), 0);
assertEquals(0, MapUtils.getDoubleValue(in, "noKey"), 0);
assertEquals(2.0, MapUtils.getDouble(in, "key", 0.0), 0);

3
src/test/java/org/apache/commons/collections4/MultiSetUtilsTest.java
View File

@ -112,8 +112,7 @@ public class MultiSetUtilsTest {
try {
MultiSetUtils.predicatedMultiSet(multiSet, object -> object.equals("a"));
fail("Predicate is violated for all elements not being 'a'");
}
catch (final IllegalArgumentException iae) {
} catch (final IllegalArgumentException iae) {
}
}
}

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

@ -684,7 +684,7 @@ public abstract class AbstractBagTest<T> extends AbstractCollectionTest<T> {
final Bag<T> bag = makeObject();
if (bag instanceof Serializable && !skipSerializedCanonicalTests() && isTestSerialization()) {
final Bag<?> bag2 = (Bag<?>) readExternalFormFromDisk(getCanonicalEmptyCollectionName(bag));
assertTrue("Bag is empty",bag2.size() == 0);
assertTrue("Bag is empty", bag2.size() == 0);
assertEquals(bag, bag2);
}
}
@ -698,7 +698,7 @@ public abstract class AbstractBagTest<T> extends AbstractCollectionTest<T> {
final Bag<T> bag = makeFullCollection();
if (bag instanceof Serializable && !skipSerializedCanonicalTests() && isTestSerialization()) {
final Bag<?> bag2 = (Bag<?>) readExternalFormFromDisk(getCanonicalFullCollectionName(bag));
assertEquals("Bag is the right size",bag.size(), bag2.size());
assertEquals("Bag is the right size", bag.size(), bag2.size());
assertEquals(bag, bag2);
}
}

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

@ -110,9 +110,8 @@ public class CollectionBagTest<T> extends AbstractCollectionTest<T> {
final Bag<T> bag = (Bag<T>) makeFullCollection();
if (bag instanceof Serializable && !skipSerializedCanonicalTests() && isTestSerialization()) {
final Bag<?> bag2 = (Bag<?>) readExternalFormFromDisk(getCanonicalFullCollectionName(bag));
assertEquals("Bag is the right size",bag.size(), bag2.size());
assertEquals("Bag is the right size", bag.size(), bag2.size());
assertEquals(bag, bag2);
}
}
}

2
src/test/java/org/apache/commons/collections4/collection/IndexedCollectionTest.java
View File

@ -113,7 +113,7 @@ public class IndexedCollectionTest extends AbstractCollectionTest<String> {
coll.add("12");
coll.add("16");
coll.add("1");
coll.addAll(asList("2","3","4"));
coll.addAll(asList("2", "3", "4"));
@SuppressWarnings("unchecked")
final IndexedCollection<Integer, String> indexed = (IndexedCollection<Integer, String>) coll;

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

@ -140,7 +140,7 @@ public abstract class AbstractComparatorTest<T> extends AbstractObjectTest {
final List<T> randomList = getComparableObjectsOrdered();
randomizeObjects(randomList);
sortObjects(randomList,comparator);
sortObjects(randomList, comparator);
final List<T> orderedList = getComparableObjectsOrdered();
@ -170,7 +170,7 @@ public abstract class AbstractComparatorTest<T> extends AbstractObjectTest {
final StringBuilder retval = new StringBuilder();
retval.append(TEST_DATA_PATH);
String colName = object.getClass().getName();
colName = colName.substring(colName.lastIndexOf(".")+1,colName.length());
colName = colName.substring(colName.lastIndexOf(".") + 1, colName.length());
retval.append(colName);
retval.append(".version");
retval.append(getCompatibilityVersion());

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

@ -70,30 +70,30 @@ public class BooleanComparatorTest extends AbstractComparatorTest<Boolean> {
@Test
public void testConstructors() {
allTests(false,new BooleanComparator());
allTests(false,new BooleanComparator(false));
allTests(true,new BooleanComparator(true));
allTests(false, new BooleanComparator());
allTests(false, new BooleanComparator(false));
allTests(true, new BooleanComparator(true));
}
@Test
public void testStaticFactoryMethods() {
allTests(false,BooleanComparator.getFalseFirstComparator());
allTests(false,BooleanComparator.booleanComparator(false));
allTests(true,BooleanComparator.getTrueFirstComparator());
allTests(true,BooleanComparator.booleanComparator(true));
allTests(false, BooleanComparator.getFalseFirstComparator());
allTests(false, BooleanComparator.booleanComparator(false));
allTests(true, BooleanComparator.getTrueFirstComparator());
allTests(true, BooleanComparator.booleanComparator(true));
}
@Test
public void testEqualsCompatibleInstance() {
assertEquals(new BooleanComparator(),new BooleanComparator(false));
assertEquals(new BooleanComparator(false),new BooleanComparator(false));
assertEquals(new BooleanComparator(false),BooleanComparator.getFalseFirstComparator());
assertSame(BooleanComparator.getFalseFirstComparator(),BooleanComparator.booleanComparator(false));
assertEquals(new BooleanComparator(), new BooleanComparator(false));
assertEquals(new BooleanComparator(false), new BooleanComparator(false));
assertEquals(new BooleanComparator(false), BooleanComparator.getFalseFirstComparator());
assertSame(BooleanComparator.getFalseFirstComparator(), BooleanComparator.booleanComparator(false));
assertEquals(new BooleanComparator(true),new BooleanComparator(true));
assertEquals(new BooleanComparator(true),BooleanComparator.getTrueFirstComparator());
assertSame(BooleanComparator.getTrueFirstComparator(),BooleanComparator.booleanComparator(true));
assertEquals(new BooleanComparator(true), new BooleanComparator(true));
assertEquals(new BooleanComparator(true), BooleanComparator.getTrueFirstComparator());
assertSame(BooleanComparator.getTrueFirstComparator(), BooleanComparator.booleanComparator(true));
assertTrue(!new BooleanComparator().equals(new BooleanComparator(true)));
assertTrue(!new BooleanComparator(true).equals(new BooleanComparator(false)));
@ -113,16 +113,16 @@ public class BooleanComparatorTest extends AbstractComparatorTest<Boolean> {
protected void trueFirstTests(final BooleanComparator comp) {
assertNotNull(comp);
assertEquals(0,comp.compare(true, true));
assertEquals(0,comp.compare(false, false));
assertEquals(0, comp.compare(true, true));
assertEquals(0, comp.compare(false, false));
assertTrue(comp.compare(false, true) > 0);
assertTrue(comp.compare(true, false) < 0);
}
protected void falseFirstTests(final BooleanComparator comp) {
assertNotNull(comp);
assertEquals(0,comp.compare(true, true));
assertEquals(0,comp.compare(false, false));
assertEquals(0, comp.compare(true, true));
assertEquals(0, comp.compare(false, false));
assertTrue(comp.compare(false, true) < 0);
assertTrue(comp.compare(true, false) > 0);
}
@ -134,35 +134,34 @@ public class BooleanComparatorTest extends AbstractComparatorTest<Boolean> {
protected void nullArgumentTests(final BooleanComparator comp) {
assertNotNull(comp);
try {
comp.compare(null,null);
comp.compare(null, null);
fail("Expected NullPointerException");
} catch(final NullPointerException e) {
} catch (final NullPointerException e) {
// expected
}
try {
comp.compare(Boolean.TRUE,null);
comp.compare(Boolean.TRUE, null);
fail("Expected NullPointerException");
} catch(final NullPointerException e) {
} catch (final NullPointerException e) {
// expected
}
try {
comp.compare(Boolean.FALSE,null);
comp.compare(Boolean.FALSE, null);
fail("Expected NullPointerException");
} catch(final NullPointerException e) {
} catch (final NullPointerException e) {
// expected
}
try {
comp.compare(null,Boolean.TRUE);
comp.compare(null, Boolean.TRUE);
fail("Expected NullPointerException");
} catch(final NullPointerException e) {
} catch (final NullPointerException e) {
// expected
}
try {
comp.compare(null,Boolean.FALSE);
comp.compare(null, Boolean.FALSE);
fail("Expected NullPointerException");
} catch(final NullPointerException e) {
} catch (final NullPointerException e) {
// expected
}
}
}

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

@ -67,7 +67,7 @@ public class ComparatorChainTest extends AbstractComparatorTest<ComparatorChainT
final Integer i1 = Integer.valueOf(4);
final Integer i2 = Integer.valueOf(6);
try {
chain.compare(i1,i2);
chain.compare(i1, i2);
fail("An exception should be thrown when a chain contains zero comparators.");
} catch (final UnsupportedOperationException e) {
}

2
src/test/java/org/apache/commons/collections4/comparators/ReverseComparatorTest.java
View File

@ -90,7 +90,7 @@ public class ReverseComparatorTest extends AbstractComparatorTest<Integer> {
final ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(buffer.toByteArray()));
final Object dest = in.readObject();
in.close();
assertEquals("obj != deserialize(serialize(obj))",comp,dest);
assertEquals("obj != deserialize(serialize(obj))", comp, dest);
}
}

126
src/test/java/org/apache/commons/collections4/iterators/CollatingIteratorTest.java
View File

@ -100,7 +100,7 @@ public class CollatingIteratorTest extends AbstractIteratorTest<Integer> {
for (int i = 0; i < evens.size(); i++) {
assertTrue(iter.hasNext());
assertEquals(evens.get(i), iter.next());
assertEquals(0,iter.getIteratorIndex());
assertEquals(0, iter.getIteratorIndex());
}
assertTrue(!iter.hasNext());
}
@ -110,7 +110,7 @@ public class CollatingIteratorTest extends AbstractIteratorTest<Integer> {
for (int i = 0; i < 20; i++) {
assertTrue(iter.hasNext());
assertEquals(Integer.valueOf(i), iter.next());
assertEquals(i % 2,iter.getIteratorIndex());
assertEquals(i % 2, iter.getIteratorIndex());
}
assertTrue(!iter.hasNext());
}
@ -119,8 +119,8 @@ public class CollatingIteratorTest extends AbstractIteratorTest<Integer> {
final CollatingIterator<Integer> iter = new CollatingIterator<>(comparator, odds.iterator(), evens.iterator());
for (int i = 0; i < 20; i++) {
assertTrue(iter.hasNext());
assertEquals(Integer.valueOf(i),iter.next());
assertEquals(i % 2 == 0 ? 1 : 0,iter.getIteratorIndex());
assertEquals(Integer.valueOf(i), iter.next());
assertEquals(i % 2 == 0 ? 1 : 0, iter.getIteratorIndex());
}
assertTrue(!iter.hasNext());
}
@ -132,10 +132,10 @@ public class CollatingIteratorTest extends AbstractIteratorTest<Integer> {
for (int i = 0; i < evens.size(); i++) {
assertTrue(iter.hasNext());
assertEquals(evens.get(i), iter.next());
assertEquals(0,iter.getIteratorIndex());
assertEquals(0, iter.getIteratorIndex());
assertTrue(iter.hasNext());
assertEquals(evens.get(i), iter.next());
assertEquals(1,iter.getIteratorIndex());
assertEquals(1, iter.getIteratorIndex());
}
assertTrue(!iter.hasNext());
}
@ -146,62 +146,62 @@ public class CollatingIteratorTest extends AbstractIteratorTest<Integer> {
iter.addIterator(evens.iterator());
iter.addIterator(odds.iterator());
assertEquals(Integer.valueOf(0),iter.next()); // even 0
assertEquals(1,iter.getIteratorIndex());
assertEquals(Integer.valueOf(1),iter.next()); // fib 1
assertEquals(0,iter.getIteratorIndex());
assertEquals(Integer.valueOf(1),iter.next()); // fib 1
assertEquals(0,iter.getIteratorIndex());
assertEquals(Integer.valueOf(1),iter.next()); // odd 1
assertEquals(2,iter.getIteratorIndex());
assertEquals(Integer.valueOf(2),iter.next()); // fib 2
assertEquals(0,iter.getIteratorIndex());
assertEquals(Integer.valueOf(2),iter.next()); // even 2
assertEquals(1,iter.getIteratorIndex());
assertEquals(Integer.valueOf(3),iter.next()); // fib 3
assertEquals(0,iter.getIteratorIndex());
assertEquals(Integer.valueOf(3),iter.next()); // odd 3
assertEquals(2,iter.getIteratorIndex());
assertEquals(Integer.valueOf(4),iter.next()); // even 4
assertEquals(1,iter.getIteratorIndex());
assertEquals(Integer.valueOf(5),iter.next()); // fib 5
assertEquals(0,iter.getIteratorIndex());
assertEquals(Integer.valueOf(5),iter.next()); // odd 5
assertEquals(2,iter.getIteratorIndex());
assertEquals(Integer.valueOf(6),iter.next()); // even 6
assertEquals(1,iter.getIteratorIndex());
assertEquals(Integer.valueOf(7),iter.next()); // odd 7
assertEquals(2,iter.getIteratorIndex());
assertEquals(Integer.valueOf(8),iter.next()); // fib 8
assertEquals(0,iter.getIteratorIndex());
assertEquals(Integer.valueOf(8),iter.next()); // even 8
assertEquals(1,iter.getIteratorIndex());
assertEquals(Integer.valueOf(9),iter.next()); // odd 9
assertEquals(2,iter.getIteratorIndex());
assertEquals(Integer.valueOf(10),iter.next()); // even 10
assertEquals(1,iter.getIteratorIndex());
assertEquals(Integer.valueOf(11),iter.next()); // odd 11
assertEquals(2,iter.getIteratorIndex());
assertEquals(Integer.valueOf(12),iter.next()); // even 12
assertEquals(1,iter.getIteratorIndex());
assertEquals(Integer.valueOf(13),iter.next()); // fib 13
assertEquals(0,iter.getIteratorIndex());
assertEquals(Integer.valueOf(13),iter.next()); // odd 13
assertEquals(2,iter.getIteratorIndex());
assertEquals(Integer.valueOf(14),iter.next()); // even 14
assertEquals(1,iter.getIteratorIndex());
assertEquals(Integer.valueOf(15),iter.next()); // odd 15
assertEquals(2,iter.getIteratorIndex());
assertEquals(Integer.valueOf(16),iter.next()); // even 16
assertEquals(1,iter.getIteratorIndex());
assertEquals(Integer.valueOf(17),iter.next()); // odd 17
assertEquals(2,iter.getIteratorIndex());
assertEquals(Integer.valueOf(18),iter.next()); // even 18
assertEquals(1,iter.getIteratorIndex());
assertEquals(Integer.valueOf(19),iter.next()); // odd 19
assertEquals(2,iter.getIteratorIndex());
assertEquals(Integer.valueOf(21),iter.next()); // fib 21
assertEquals(0,iter.getIteratorIndex());
assertEquals(Integer.valueOf(0), iter.next()); // even 0
assertEquals(1, iter.getIteratorIndex());
assertEquals(Integer.valueOf(1), iter.next()); // fib 1
assertEquals(0, iter.getIteratorIndex());
assertEquals(Integer.valueOf(1), iter.next()); // fib 1
assertEquals(0, iter.getIteratorIndex());
assertEquals(Integer.valueOf(1), iter.next()); // odd 1
assertEquals(2, iter.getIteratorIndex());
assertEquals(Integer.valueOf(2), iter.next()); // fib 2
assertEquals(0, iter.getIteratorIndex());
assertEquals(Integer.valueOf(2), iter.next()); // even 2
assertEquals(1, iter.getIteratorIndex());
assertEquals(Integer.valueOf(3), iter.next()); // fib 3
assertEquals(0, iter.getIteratorIndex());
assertEquals(Integer.valueOf(3), iter.next()); // odd 3
assertEquals(2, iter.getIteratorIndex());
assertEquals(Integer.valueOf(4), iter.next()); // even 4
assertEquals(1, iter.getIteratorIndex());
assertEquals(Integer.valueOf(5), iter.next()); // fib 5
assertEquals(0, iter.getIteratorIndex());
assertEquals(Integer.valueOf(5), iter.next()); // odd 5
assertEquals(2, iter.getIteratorIndex());
assertEquals(Integer.valueOf(6), iter.next()); // even 6
assertEquals(1, iter.getIteratorIndex());
assertEquals(Integer.valueOf(7), iter.next()); // odd 7
assertEquals(2, iter.getIteratorIndex());
assertEquals(Integer.valueOf(8), iter.next()); // fib 8
assertEquals(0, iter.getIteratorIndex());
assertEquals(Integer.valueOf(8), iter.next()); // even 8
assertEquals(1, iter.getIteratorIndex());
assertEquals(Integer.valueOf(9), iter.next()); // odd 9
assertEquals(2, iter.getIteratorIndex());
assertEquals(Integer.valueOf(10), iter.next()); // even 10
assertEquals(1, iter.getIteratorIndex());
assertEquals(Integer.valueOf(11), iter.next()); // odd 11
assertEquals(2, iter.getIteratorIndex());
assertEquals(Integer.valueOf(12), iter.next()); // even 12
assertEquals(1, iter.getIteratorIndex());
assertEquals(Integer.valueOf(13), iter.next()); // fib 13
assertEquals(0, iter.getIteratorIndex());
assertEquals(Integer.valueOf(13), iter.next()); // odd 13
assertEquals(2, iter.getIteratorIndex());
assertEquals(Integer.valueOf(14), iter.next()); // even 14
assertEquals(1, iter.getIteratorIndex());
assertEquals(Integer.valueOf(15), iter.next()); // odd 15
assertEquals(2, iter.getIteratorIndex());
assertEquals(Integer.valueOf(16), iter.next()); // even 16
assertEquals(1, iter.getIteratorIndex());
assertEquals(Integer.valueOf(17), iter.next()); // odd 17
assertEquals(2, iter.getIteratorIndex());
assertEquals(Integer.valueOf(18), iter.next()); // even 18
assertEquals(1, iter.getIteratorIndex());
assertEquals(Integer.valueOf(19), iter.next()); // odd 19
assertEquals(2, iter.getIteratorIndex());
assertEquals(Integer.valueOf(21), iter.next()); // fib 21
assertEquals(0, iter.getIteratorIndex());
assertTrue(!iter.hasNext());
}
@ -218,7 +218,7 @@ public class CollatingIteratorTest extends AbstractIteratorTest<Integer> {
iter.remove();
}
}
assertEquals(expectedSize,evens.size());
assertEquals(expectedSize, evens.size());
}
public void testRemoveFromDouble() {

3
src/test/java/org/apache/commons/collections4/iterators/FilterIteratorTest.java
View File

@ -150,8 +150,7 @@ public class FilterIteratorTest<E> extends AbstractIteratorTest<E> {
try {
iterator.next();
fail("NoSuchElementException expected");
}
catch (final NoSuchElementException e) {
} catch (final NoSuchElementException e) {
// success
}
}

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

@ -113,7 +113,7 @@ public class FilterListIteratorTest {
@Test
public void testWalkLists() {
// this just confirms that our walkLists method works OK
walkLists(list,list.listIterator());
walkLists(list, list.listIterator());
}
@Test
@ -257,8 +257,8 @@ public class FilterListIteratorTest {
{
final FilterListIterator<Integer> filtered = new FilterListIterator<>(list.listIterator(), threePred);
final ListIterator<Integer> expected = threes.listIterator();
walkForward(expected,filtered);
previousPreviousNext(expected,filtered);
walkForward(expected, filtered);
previousPreviousNext(expected, filtered);
}
{
final FilterListIterator<Integer> filtered = new FilterListIterator<>(list.listIterator(), truePred);
@ -347,10 +347,10 @@ public class FilterListIteratorTest {
final ListIterator<E> expected = list.listIterator();
// walk all the way forward
walkForward(expected,testing);
walkForward(expected, testing);
// walk all the way back
walkBackward(expected,testing);
walkBackward(expected, testing);
// forward,back,forward
while (expected.hasNext()) {

20
src/test/java/org/apache/commons/collections4/iterators/IteratorChainTest.java
View File

@ -134,9 +134,9 @@ public class IteratorChainTest extends AbstractIteratorTest<String> {
}
}
assertTrue("List is empty",list1.size() == 0);
assertTrue("List is empty",list2.size() == 1);
assertTrue("List is empty",list3.size() == 0);
assertTrue("List is empty", list1.size() == 0);
assertTrue("List is empty", list2.size() == 1);
assertTrue("List is empty", list3.size() == 0);
}
public void testFirstIteratorIsEmptyBug() {
@ -148,13 +148,13 @@ public class IteratorChainTest extends AbstractIteratorTest<String> {
final IteratorChain<String> chain = new IteratorChain<>();
chain.addIterator(empty.iterator());
chain.addIterator(notEmpty.iterator());
assertTrue("should have next",chain.hasNext());
assertEquals("A",chain.next());
assertTrue("should have next",chain.hasNext());
assertEquals("B",chain.next());
assertTrue("should have next",chain.hasNext());
assertEquals("C",chain.next());
assertTrue("should not have next",!chain.hasNext());
assertTrue("should have next", chain.hasNext());
assertEquals("A", chain.next());
assertTrue("should have next", chain.hasNext());
assertEquals("B", chain.next());
assertTrue("should have next", chain.hasNext());
assertEquals("C", chain.next());
assertTrue("should not have next", !chain.hasNext());
}
public void testEmptyChain() {

21
src/test/java/org/apache/commons/collections4/iterators/LazyIteratorChainTest.java
View File

@ -148,9 +148,9 @@ public class LazyIteratorChainTest extends AbstractIteratorTest<String> {
}
}
assertTrue("List is empty",list1.size() == 0);
assertTrue("List is empty",list2.size() == 1);
assertTrue("List is empty",list3.size() == 0);
assertTrue("List is empty", list1.size() == 0);
assertTrue("List is empty", list2.size() == 1);
assertTrue("List is empty", list3.size() == 0);
}
public void testFirstIteratorIsEmptyBug() {
@ -171,13 +171,13 @@ public class LazyIteratorChainTest extends AbstractIteratorTest<String> {
return null;
}
};
assertTrue("should have next",chain.hasNext());
assertEquals("A",chain.next());
assertTrue("should have next",chain.hasNext());
assertEquals("B",chain.next());
assertTrue("should have next",chain.hasNext());
assertEquals("C",chain.next());
assertTrue("should not have next",!chain.hasNext());
assertTrue("should have next", chain.hasNext());
assertEquals("A", chain.next());
assertTrue("should have next", chain.hasNext());
assertEquals("B", chain.next());
assertTrue("should have next", chain.hasNext());
assertEquals("C", chain.next());
assertTrue("should not have next", !chain.hasNext());
}
public void testEmptyChain() {
@ -192,5 +192,4 @@ public class LazyIteratorChainTest extends AbstractIteratorTest<String> {
fail();
} catch (final IllegalStateException ex) {}
}
}

2
src/test/java/org/apache/commons/collections4/iterators/SingletonIteratorTest.java
View File

@ -85,7 +85,7 @@ public class SingletonIteratorTest<E> extends AbstractIteratorTest<E> {
public void testSingletonIteratorRemove() {
final ResettableIterator<E> iter = new SingletonIterator<>((E) "xyzzy");
assertTrue(iter.hasNext());
assertEquals("xyzzy",iter.next());
assertEquals("xyzzy", iter.next());
iter.remove();
iter.reset();
assertTrue(! iter.hasNext());

56
src/test/java/org/apache/commons/collections4/iterators/ZippingIteratorTest.java
View File

@ -125,34 +125,34 @@ public class ZippingIteratorTest extends AbstractIteratorTest<Integer> {
public void testIterateFibEvenOdd() {
final ZippingIterator<Integer> iter = new ZippingIterator<>(fib.iterator(), evens.iterator(), odds.iterator());
assertEquals(Integer.valueOf(1),iter.next()); // fib 1
assertEquals(Integer.valueOf(0),iter.next()); // even 0
assertEquals(Integer.valueOf(1),iter.next()); // odd 1
assertEquals(Integer.valueOf(1),iter.next()); // fib 1
assertEquals(Integer.valueOf(2),iter.next()); // even 2
assertEquals(Integer.valueOf(3),iter.next()); // odd 3
assertEquals(Integer.valueOf(2),iter.next()); // fib 2
assertEquals(Integer.valueOf(4),iter.next()); // even 4
assertEquals(Integer.valueOf(5),iter.next()); // odd 5
assertEquals(Integer.valueOf(3),iter.next()); // fib 3
assertEquals(Integer.valueOf(6),iter.next()); // even 6
assertEquals(Integer.valueOf(7),iter.next()); // odd 7
assertEquals(Integer.valueOf(5),iter.next()); // fib 5
assertEquals(Integer.valueOf(8),iter.next()); // even 8
assertEquals(Integer.valueOf(9),iter.next()); // odd 9
assertEquals(Integer.valueOf(8),iter.next()); // fib 8
assertEquals(Integer.valueOf(10),iter.next()); // even 10
assertEquals(Integer.valueOf(11),iter.next()); // odd 11
assertEquals(Integer.valueOf(13),iter.next()); // fib 13
assertEquals(Integer.valueOf(12),iter.next()); // even 12
assertEquals(Integer.valueOf(13),iter.next()); // odd 13
assertEquals(Integer.valueOf(21),iter.next()); // fib 21
assertEquals(Integer.valueOf(14),iter.next()); // even 14
assertEquals(Integer.valueOf(15),iter.next()); // odd 15
assertEquals(Integer.valueOf(16),iter.next()); // even 16
assertEquals(Integer.valueOf(17),iter.next()); // odd 17
assertEquals(Integer.valueOf(18),iter.next()); // even 18
assertEquals(Integer.valueOf(19),iter.next()); // odd 19
assertEquals(Integer.valueOf(1), iter.next()); // fib 1
assertEquals(Integer.valueOf(0), iter.next()); // even 0
assertEquals(Integer.valueOf(1), iter.next()); // odd 1
assertEquals(Integer.valueOf(1), iter.next()); // fib 1
assertEquals(Integer.valueOf(2), iter.next()); // even 2
assertEquals(Integer.valueOf(3), iter.next()); // odd 3
assertEquals(Integer.valueOf(2), iter.next()); // fib 2
assertEquals(Integer.valueOf(4), iter.next()); // even 4
assertEquals(Integer.valueOf(5), iter.next()); // odd 5
assertEquals(Integer.valueOf(3), iter.next()); // fib 3
assertEquals(Integer.valueOf(6), iter.next()); // even 6
assertEquals(Integer.valueOf(7), iter.next()); // odd 7
assertEquals(Integer.valueOf(5), iter.next()); // fib 5
assertEquals(Integer.valueOf(8), iter.next()); // even 8
assertEquals(Integer.valueOf(9), iter.next()); // odd 9
assertEquals(Integer.valueOf(8), iter.next()); // fib 8
assertEquals(Integer.valueOf(10), iter.next()); // even 10
assertEquals(Integer.valueOf(11), iter.next()); // odd 11
assertEquals(Integer.valueOf(13), iter.next()); // fib 13
assertEquals(Integer.valueOf(12), iter.next()); // even 12
assertEquals(Integer.valueOf(13), iter.next()); // odd 13
assertEquals(Integer.valueOf(21), iter.next()); // fib 21
assertEquals(Integer.valueOf(14), iter.next()); // even 14
assertEquals(Integer.valueOf(15), iter.next()); // odd 15
assertEquals(Integer.valueOf(16), iter.next()); // even 16
assertEquals(Integer.valueOf(17), iter.next()); // odd 17
assertEquals(Integer.valueOf(18), iter.next()); // even 18
assertEquals(Integer.valueOf(19), iter.next()); // odd 19
assertTrue(!iter.hasNext());
}

2
src/test/java/org/apache/commons/collections4/list/AbstractListTest.java
View File

@ -1112,7 +1112,7 @@ public abstract class AbstractListTest<E> extends AbstractCollectionTest<E> {
// old serialized tests
return;
}
assertEquals("List is the right size",list.size(), list2.size());
assertEquals("List is the right size", list.size(), list2.size());
assertEquals(list, list2);
}
}

124
src/test/java/org/apache/commons/collections4/list/CursorableLinkedListTest.java
View File

@ -56,23 +56,23 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
@SuppressWarnings("unchecked")
public void testAdd() {
assertEquals("[]",list.toString());
assertEquals("[]", list.toString());
assertTrue(list.add((E) Integer.valueOf(1)));
assertEquals("[1]",list.toString());
assertEquals("[1]", list.toString());
assertTrue(list.add((E) Integer.valueOf(2)));
assertEquals("[1, 2]",list.toString());
assertEquals("[1, 2]", list.toString());
assertTrue(list.add((E) Integer.valueOf(3)));
assertEquals("[1, 2, 3]",list.toString());
assertEquals("[1, 2, 3]", list.toString());
assertTrue(list.addFirst((E) Integer.valueOf(0)));
assertEquals("[0, 1, 2, 3]",list.toString());
assertEquals("[0, 1, 2, 3]", list.toString());
assertTrue(list.addLast((E) Integer.valueOf(4)));
assertEquals("[0, 1, 2, 3, 4]",list.toString());
list.add(0,(E) Integer.valueOf(-2));
assertEquals("[-2, 0, 1, 2, 3, 4]",list.toString());
list.add(1,(E) Integer.valueOf(-1));
assertEquals("[-2, -1, 0, 1, 2, 3, 4]",list.toString());
list.add(7,(E) Integer.valueOf(5));
assertEquals("[-2, -1, 0, 1, 2, 3, 4, 5]",list.toString());
assertEquals("[0, 1, 2, 3, 4]", list.toString());
list.add(0, (E) Integer.valueOf(-2));
assertEquals("[-2, 0, 1, 2, 3, 4]", list.toString());
list.add(1, (E) Integer.valueOf(-1));
assertEquals("[-2, -1, 0, 1, 2, 3, 4]", list.toString());
list.add(7, (E) Integer.valueOf(5));
assertEquals("[-2, -1, 0, 1, 2, 3, 4, 5]", list.toString());
final List<E> list2 = new LinkedList<>();
list2.add((E) "A");
@ -80,34 +80,34 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
list2.add((E) "C");
assertTrue(list.addAll(list2));
assertEquals("[-2, -1, 0, 1, 2, 3, 4, 5, A, B, C]",list.toString());
assertTrue(list.addAll(3,list2));
assertEquals("[-2, -1, 0, A, B, C, 1, 2, 3, 4, 5, A, B, C]",list.toString());
assertEquals("[-2, -1, 0, 1, 2, 3, 4, 5, A, B, C]", list.toString());
assertTrue(list.addAll(3, list2));
assertEquals("[-2, -1, 0, A, B, C, 1, 2, 3, 4, 5, A, B, C]", list.toString());
}
@SuppressWarnings("unchecked")
public void testClear() {
assertEquals(0,list.size());
assertEquals(0, list.size());
assertTrue(list.isEmpty());
list.clear();
assertEquals(0,list.size());
assertEquals(0, list.size());
assertTrue(list.isEmpty());
list.add((E) "element");
assertEquals(1,list.size());
assertEquals(1, list.size());
assertTrue(!list.isEmpty());
list.clear();
assertEquals(0,list.size());
assertEquals(0, list.size());
assertTrue(list.isEmpty());
list.add((E) "element1");
list.add((E) "element2");
assertEquals(2,list.size());
assertEquals(2, list.size());
assertTrue(!list.isEmpty());
list.clear();
assertEquals(0,list.size());
assertEquals(0, list.size());
assertTrue(list.isEmpty());
for (int i = 0; i < 1000; i++) {
@ -117,7 +117,7 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
assertTrue(!list.isEmpty());
list.clear();
assertEquals(0,list.size());
assertEquals(0, list.size());
assertTrue(list.isEmpty());
}
@ -830,10 +830,10 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
@SuppressWarnings("unchecked")
public void testEqualsAndHashCode() {
assertTrue(list.equals(list));
assertEquals(list.hashCode(),list.hashCode());
assertEquals(list.hashCode(), list.hashCode());
list.add((E) "A");
assertTrue(list.equals(list));
assertEquals(list.hashCode(),list.hashCode());
assertEquals(list.hashCode(), list.hashCode());
final CursorableLinkedList<E> list2 = new CursorableLinkedList<>();
assertTrue(!list.equals(list2));
@ -844,7 +844,7 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
assertTrue(!list3.equals(list));
assertTrue(list2.equals(list3));
assertTrue(list3.equals(list2));
assertEquals(list2.hashCode(),list3.hashCode());
assertEquals(list2.hashCode(), list3.hashCode());
list2.add((E) "A");
assertTrue(list.equals(list2));
@ -855,7 +855,7 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
list3.add((E) "A");
assertTrue(list2.equals(list3));
assertTrue(list3.equals(list2));
assertEquals(list2.hashCode(),list3.hashCode());
assertEquals(list2.hashCode(), list3.hashCode());
list.add((E) "B");
assertTrue(list.equals(list));
@ -871,7 +871,7 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
assertTrue(list2.equals(list));
assertTrue(list2.equals(list3));
assertTrue(list3.equals(list2));
assertEquals(list2.hashCode(),list3.hashCode());
assertEquals(list2.hashCode(), list3.hashCode());
list.add((E) "C");
list2.add((E) "C");
@ -881,8 +881,8 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
assertTrue(list2.equals(list));
assertTrue(list2.equals(list3));
assertTrue(list3.equals(list2));
assertEquals(list.hashCode(),list2.hashCode());
assertEquals(list2.hashCode(),list3.hashCode());
assertEquals(list.hashCode(), list2.hashCode());
assertEquals(list2.hashCode(), list3.hashCode());
list.add((E) "D");
list2.addFirst((E) "D");
@ -901,10 +901,10 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
}
assertTrue(list.add((E) "A"));
assertEquals("A",list.get(0));
assertEquals("A", list.get(0));
assertTrue(list.add((E) "B"));
assertEquals("A",list.get(0));
assertEquals("B",list.get(1));
assertEquals("A", list.get(0));
assertEquals("B", list.get(1));
try {
list.get(-1);
@ -923,23 +923,23 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
@SuppressWarnings("unchecked")
public void testIndexOf() {
assertEquals(-1,list.indexOf("A"));
assertEquals(-1,list.lastIndexOf("A"));
assertEquals(-1, list.indexOf("A"));
assertEquals(-1, list.lastIndexOf("A"));
list.add((E) "A");
assertEquals(0,list.indexOf("A"));
assertEquals(0,list.lastIndexOf("A"));
assertEquals(-1,list.indexOf("B"));
assertEquals(-1,list.lastIndexOf("B"));
assertEquals(0, list.indexOf("A"));
assertEquals(0, list.lastIndexOf("A"));
assertEquals(-1, list.indexOf("B"));
assertEquals(-1, list.lastIndexOf("B"));
list.add((E) "B");
assertEquals(0,list.indexOf("A"));
assertEquals(0,list.lastIndexOf("A"));
assertEquals(1,list.indexOf("B"));
assertEquals(1,list.lastIndexOf("B"));
assertEquals(0, list.indexOf("A"));
assertEquals(0, list.lastIndexOf("A"));
assertEquals(1, list.indexOf("B"));
assertEquals(1, list.lastIndexOf("B"));
list.addFirst((E) "B");
assertEquals(1,list.indexOf("A"));
assertEquals(1,list.lastIndexOf("A"));
assertEquals(0,list.indexOf("B"));
assertEquals(2,list.lastIndexOf("B"));
assertEquals(1, list.indexOf("A"));
assertEquals(1, list.lastIndexOf("A"));
assertEquals(0, list.indexOf("B"));
assertEquals(2, list.lastIndexOf("B"));
}
@SuppressWarnings("unchecked")
@ -1122,32 +1122,32 @@ public class CursorableLinkedListTest<E> extends AbstractLinkedListTest<E> {
} catch(final IllegalStateException e) {
// expected
}
assertEquals("1",it.next());
assertEquals("2",it.next());
assertEquals("[1, 2, 3, 4, 5]",list.toString());
assertEquals("1", it.next());
assertEquals("2", it.next());
assertEquals("[1, 2, 3, 4, 5]", list.toString());
it.remove();
assertEquals("[1, 3, 4, 5]",list.toString());
assertEquals("3",it.next());
assertEquals("3",it.previous());
assertEquals("1",it.previous());
assertEquals("[1, 3, 4, 5]", list.toString());
assertEquals("3", it.next());
assertEquals("3", it.previous());
assertEquals("1", it.previous());
it.remove();
assertEquals("[3, 4, 5]",list.toString());
assertEquals("[3, 4, 5]", list.toString());
assertTrue(!it.hasPrevious());
assertEquals("3",it.next());
assertEquals("3", it.next());
it.remove();
assertEquals("[4, 5]",list.toString());
assertEquals("[4, 5]", list.toString());
try {
it.remove();
} catch(final IllegalStateException e) {
} catch (final IllegalStateException e) {
// expected
}
assertEquals("4",it.next());
assertEquals("5",it.next());
assertEquals("4", it.next());
assertEquals("5", it.next());
it.remove();
assertEquals("[4]",list.toString());
assertEquals("4",it.previous());
assertEquals("[4]", list.toString());
assertEquals("4", it.previous());
it.remove();
assertEquals("[]",list.toString());
assertEquals("[]", list.toString());
}
@Override

2
src/test/java/org/apache/commons/collections4/list/FixedSizeListTest.java
View File

@ -96,7 +96,7 @@ public class FixedSizeListTest<E> extends AbstractListTest<E> {
final FixedSizeList<String> fixedSizeList = initFixedSizeList();
try {
fixedSizeList.add(2,"New Value");
fixedSizeList.add(2, "New Value");
fail();
} catch (final UnsupportedOperationException ex) {}
}

2
src/test/java/org/apache/commons/collections4/list/LazyListTest.java
View File

@ -106,7 +106,7 @@ public class LazyListTest extends AbstractObjectTest {
assertFalse(list.isEmpty());
assertNotNull(fourthElement);
list.remove(3);
list.add(3,null);
list.add(3, null);
fourthElement = list.get(3);
assertNotNull(fourthElement);
}

2
src/test/java/org/apache/commons/collections4/list/PredicatedListTest.java
View File

@ -119,7 +119,7 @@ public class PredicatedListTest<E> extends AbstractListTest<E> {
elements.add((E) "one");
elements.add((E) "two");
elements.add((E) "three");
list.addAll(1,elements);
list.addAll(1, elements);
assertTrue("List should contain legal element",
list.contains("zero"));
assertTrue("List should contain legal element",

8
src/test/java/org/apache/commons/collections4/map/AbstractMapTest.java
View File

@ -338,8 +338,8 @@ public abstract class AbstractMapTest<K, V> extends AbstractObjectTest {
*/
public Object[] getOtherNonNullStringElements() {
return new Object[] {
"For","then","despite",/* of */"space","I","would","be","brought",
"From","limits","far","remote","where","thou","dost","stay"
"For", "then", "despite", /* of */"space", "I", "would", "be", "brought",
"From", "limits", "far", "remote", "where", "thou", "dost", "stay"
};
}
@ -1437,7 +1437,7 @@ public abstract class AbstractMapTest<K, V> extends AbstractObjectTest {
final Set<Map.Entry<K, V>> entrySet = getMap().entrySet();
final HashSet<Map.Entry<K, V>> comparisonSet = new HashSet<>(entrySet);
try {
assertFalse(entrySet.removeAll(Collections.<Map.Entry<K, V>> emptySet()));
assertFalse(entrySet.removeAll(Collections.<Map.Entry<K, V>>emptySet()));
} catch (final UnsupportedOperationException e) {
return;
}
@ -1478,7 +1478,7 @@ public abstract class AbstractMapTest<K, V> extends AbstractObjectTest {
}
assertEquals(sampleKeys.length, getMap().size());
try {
assertTrue(entrySet.retainAll(Collections.<Map.Entry<K, V>> emptySet()));
assertTrue(entrySet.retainAll(Collections.<Map.Entry<K, V>>emptySet()));
} catch (final UnsupportedOperationException e) {
return;
}

2
src/test/java/org/apache/commons/collections4/map/CaseInsensitiveMapTest.java
View File

@ -146,7 +146,7 @@ public class CaseInsensitiveMapTest<K, V> extends AbstractIterableMapTest<K, V>
* Test for <a href="https://issues.apache.org/jira/browse/COLLECTIONS-323">COLLECTIONS-323</a>.
*/
public void testInitialCapacityZero() {
final CaseInsensitiveMap<String,String> map = new CaseInsensitiveMap<>(0);
final CaseInsensitiveMap<String, String> map = new CaseInsensitiveMap<>(0);
assertEquals(1, map.data.length);
}
}

2
src/test/java/org/apache/commons/collections4/map/HashedMapTest.java
View File

@ -73,7 +73,7 @@ public class HashedMapTest<K, V> extends AbstractIterableMapTest<K, V> {
* Test for <a href="https://issues.apache.org/jira/browse/COLLECTIONS-323">COLLECTIONS-323</a>.
*/
public void testInitialCapacityZero() {
final HashedMap<String,String> map = new HashedMap<>(0);
final HashedMap<String, String> map = new HashedMap<>(0);
assertEquals(1, map.data.length);
}
}

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

@ -54,26 +54,26 @@ public class LazyMapTest<K, V> extends AbstractIterableMapTest<K, V> {
@Test
public void mapGetWithFactory() {
Map<Integer, Number> map = lazyMap(new HashMap<Integer,Number>(), oneFactory);
Map<Integer, Number> map = lazyMap(new HashMap<Integer, Number>(), oneFactory);
assertEquals(0, map.size());
final Number i1 = map.get("Five");
assertEquals(1, i1);
assertEquals(1, map.size());
final Number i2 = map.get(new String(new char[] {'F','i','v','e'}));
final Number i2 = map.get(new String(new char[] {'F', 'i', 'v', 'e'}));
assertEquals(1, i2);
assertEquals(1, map.size());
assertSame(i1, i2);
map = lazyMap(new HashMap<Integer,Number>(), FactoryUtils.<Long>nullFactory());
map = lazyMap(new HashMap<Integer, Number>(), FactoryUtils.<Long>nullFactory());
final Object o = map.get("Five");
assertEquals(null,o);
assertEquals(null, o);
assertEquals(1, map.size());
}
@Test
public void mapGetWithTransformer() {
final Transformer<Number, Integer> intConverter = input -> input.intValue();
final Map<Long, Number> map = lazyMap(new HashMap<Long,Number>(), intConverter );
final Map<Long, Number> map = lazyMap(new HashMap<Long, Number>(), intConverter);
assertEquals(0, map.size());
final Number i1 = map.get(123L);
assertEquals(123, i1);

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

@ -81,14 +81,14 @@ public class LazySortedMapTest<K, V> extends AbstractSortedMapTest<K, V> {
map = lazySortedMap(new TreeMap<Integer, Number>(), FactoryUtils.<Number>nullFactory());
final Number o = map.get(5);
assertEquals(null,o);
assertEquals(null, o);
assertEquals(1, map.size());
}
//-----------------------------------------------------------------------
public void testSortOrder() {
final SortedMap<String, Number> map = lazySortedMap(new TreeMap<String,Number>(), oneFactory);
final SortedMap<String, Number> map = lazySortedMap(new TreeMap<String, Number>(), oneFactory);
map.put("A", 5);
map.get("B"); // Entry with value "One" created
map.put("C", 8);
@ -99,7 +99,7 @@ public class LazySortedMapTest<K, V> extends AbstractSortedMapTest<K, V> {
assertEquals("Last key in head map should be B",
"B", map.headMap("C").lastKey());
assertEquals("Last key in submap should be B",
"B", map.subMap("A","C").lastKey());
"B", map.subMap("A", "C").lastKey());
final Comparator<?> c = map.comparator();
assertTrue("natural order, so comparator should be null",
@ -118,7 +118,7 @@ public class LazySortedMapTest<K, V> extends AbstractSortedMapTest<K, V> {
assertEquals("Last key in head map should be B",
"B", map.headMap("A").lastKey());
assertEquals("Last key in submap should be B",
"B", map.subMap("C","A").lastKey());
"B", map.subMap("C", "A").lastKey());
final Comparator<?> c = map.comparator();
assertTrue("natural order, so comparator should be null",
@ -136,7 +136,7 @@ public class LazySortedMapTest<K, V> extends AbstractSortedMapTest<K, V> {
// expected
}
try {
map = lazySortedMap((SortedMap<Integer,Number>) null, transformer);
map = lazySortedMap((SortedMap<Integer, Number>) null, transformer);
fail("Expecting NullPointerException for null map");
} catch (final NullPointerException e) {
// expected

2
src/test/java/org/apache/commons/collections4/map/LinkedMapTest.java
View File

@ -300,7 +300,7 @@ public class LinkedMapTest<K, V> extends AbstractOrderedMapTest<K, V> {
* Test for <a href="https://issues.apache.org/jira/browse/COLLECTIONS-323">COLLECTIONS-323</a>.
*/
public void testInitialCapacityZero() {
final LinkedMap<String,String> map = new LinkedMap<>(0);
final LinkedMap<String, String> map = new LinkedMap<>(0);
assertEquals(1, map.data.length);
}
}

4
src/test/java/org/apache/commons/collections4/map/PredicatedSortedMapTest.java
View File

@ -172,7 +172,7 @@ public class PredicatedSortedMapTest<K, V> extends AbstractSortedMapTest<K, V> {
assertEquals("Last key in head map should be B",
"B", map.headMap((K) "C").lastKey());
assertEquals("Last key in submap should be B",
"B", map.subMap((K) "A",(K) "C").lastKey());
"B", map.subMap((K) "A", (K) "C").lastKey());
final Comparator<? super K> c = map.comparator();
assertTrue("natural order, so comparator should be null",
@ -204,7 +204,7 @@ public class PredicatedSortedMapTest<K, V> extends AbstractSortedMapTest<K, V> {
assertEquals("Last key in head map should be B",
"B", map.headMap((K) "A").lastKey());
assertEquals("Last key in submap should be B",
"B", map.subMap((K) "C",(K) "A").lastKey());
"B", map.subMap((K) "C", (K) "A").lastKey());
final Comparator<? super K> c = map.comparator();
assertTrue("reverse order, so comparator should be reverseStringComparator",

2
src/test/java/org/apache/commons/collections4/map/ReferenceMapTest.java
View File

@ -313,7 +313,7 @@ public class ReferenceMapTest<K, V> extends AbstractIterableMapTest<K, V> {
try (ObjectInputStream in = new ObjectInputStream(bais)) {
@SuppressWarnings("unchecked")
final
ReferenceMap<String, String> deserialisedMap = (ReferenceMap<String,String>) in.readObject();
ReferenceMap<String, String> deserialisedMap = (ReferenceMap<String, String>) in.readObject();
assertEquals(1, deserialisedMap.size());
assertEquals(serialiseMap.data.length, deserialisedMap.data.length);
}

2
src/test/java/org/apache/commons/collections4/map/TransformedMapTest.java
View File

@ -41,7 +41,7 @@ public class TransformedMapTest<K, V> extends AbstractIterableMapTest<K, V> {
@Override
public IterableMap<K, V> makeObject() {
return TransformedMap.transformingMap(new HashMap<K, V>(), TransformerUtils.<K>nopTransformer(),
TransformerUtils.<V> nopTransformer());
TransformerUtils.<V>nopTransformer());
}
//-----------------------------------------------------------------------

2
src/test/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMapTest.java
View File

@ -62,7 +62,7 @@ public abstract class AbstractMultiValuedMapTest<K, V> extends AbstractObjectTes
}
@Override
abstract public MultiValuedMap<K, V> makeObject();
public abstract MultiValuedMap<K, V> makeObject();
@Override
public String getCompatibilityVersion() {

4
src/test/java/org/apache/commons/collections4/multiset/AbstractMultiSetTest.java
View File

@ -696,7 +696,7 @@ public abstract class AbstractMultiSetTest<T> extends AbstractCollectionTest<T>
final MultiSet<T> multiset = makeObject();
if (multiset instanceof Serializable && !skipSerializedCanonicalTests() && isTestSerialization()) {
final MultiSet<?> multiset2 = (MultiSet<?>) readExternalFormFromDisk(getCanonicalEmptyCollectionName(multiset));
assertTrue("MultiSet is empty",multiset2.size() == 0);
assertTrue("MultiSet is empty", multiset2.size() == 0);
assertEquals(multiset, multiset2);
}
}
@ -710,7 +710,7 @@ public abstract class AbstractMultiSetTest<T> extends AbstractCollectionTest<T>
final MultiSet<T> multiset = makeFullCollection();
if (multiset instanceof Serializable && !skipSerializedCanonicalTests() && isTestSerialization()) {
final MultiSet<?> multiset2 = (MultiSet<?>) readExternalFormFromDisk(getCanonicalFullCollectionName(multiset));
assertEquals("MultiSet is the right size",multiset.size(), multiset2.size());
assertEquals("MultiSet is the right size", multiset.size(), multiset2.size());
assertEquals(multiset, multiset2);
}
}

2
src/test/java/org/apache/commons/collections4/multiset/PredicatedMultiSetTest.java
View File

@ -75,7 +75,7 @@ public class PredicatedMultiSetTest<T> extends AbstractMultiSetTest<T> {
assertEquals(true, multiset.contains(els[i]));
}
Set<T> set = ((PredicatedMultiSet<T>) multiset).uniqueSet();
assertTrue("Unique set contains the first element",set.contains(els[0]));
assertTrue("Unique set contains the first element", set.contains(els[0]));
assertEquals(true, multiset.remove(els[0]));
set = ((PredicatedMultiSet<T>) multiset).uniqueSet();
assertTrue("Unique set does not contain anymore the first element",

4
src/test/java/org/apache/commons/collections4/multiset/UnmodifiableMultiSetTest.java
View File

@ -96,7 +96,7 @@ public class UnmodifiableMultiSetTest<E> extends AbstractMultiSetTest<E> {
final MultiSet<E> multiset = makeFullCollection();
final MultiSet<E> unmodifiableMultiSet = UnmodifiableMultiSet.unmodifiableMultiSet(multiset);
try {
unmodifiableMultiSet.add((E) "One",1);
unmodifiableMultiSet.add((E) "One", 1);
fail();
} catch (final UnsupportedOperationException ex) {}
}
@ -114,7 +114,7 @@ public class UnmodifiableMultiSetTest<E> extends AbstractMultiSetTest<E> {
final MultiSet<E> multiset = makeFullCollection();
final MultiSet<E> unmodifiableMultiSet = UnmodifiableMultiSet.unmodifiableMultiSet(multiset);
try {
unmodifiableMultiSet.setCount((E) "One",2);
unmodifiableMultiSet.setCount((E) "One", 2);
fail();
} catch (final UnsupportedOperationException ex) {}
}

8
src/test/java/org/apache/commons/collections4/queue/CircularFifoQueueTest.java
View File

@ -435,13 +435,13 @@ public class CircularFifoQueueTest<E> extends AbstractQueueTest<E> {
public void testDefaultSizeAndGetError1() {
final CircularFifoQueue<E> fifo = new CircularFifoQueue<>();
assertEquals(32,fifo.maxSize());
assertEquals(32, fifo.maxSize());
fifo.add((E) "1");
fifo.add((E) "2");
fifo.add((E) "3");
fifo.add((E) "4");
fifo.add((E) "5");
assertEquals(5,fifo.size());
assertEquals(5, fifo.size());
try {
fifo.get(5);
} catch (final NoSuchElementException ex) {
@ -452,13 +452,13 @@ public class CircularFifoQueueTest<E> extends AbstractQueueTest<E> {
public void testDefaultSizeAndGetError2() {
final CircularFifoQueue<E> fifo = new CircularFifoQueue<>();
assertEquals(32,fifo.maxSize());
assertEquals(32, fifo.maxSize());
fifo.add((E) "1");
fifo.add((E) "2");
fifo.add((E) "3");
fifo.add((E) "4");
fifo.add((E) "5");
assertEquals(5,fifo.size());
assertEquals(5, fifo.size());
try {
fifo.get(-2);
} catch (final NoSuchElementException ex) {

3
src/test/java/org/apache/commons/collections4/set/CompositeSetTest.java
View File

@ -132,8 +132,7 @@ public class CompositeSetTest<E> extends AbstractSetTest<E> {
try {
set.addComposited(three);
fail("IllegalArgumentException should have been thrown");
}
catch (final IllegalArgumentException e) {
} catch (final IllegalArgumentException e) {
// expected
}
}