You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by ch...@apache.org on 2017/07/11 17:54:55 UTC
[10/77] [abbrv] commons-collections git commit: finish generics
(minus one class)
http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/iterators/AbstractTestOrderedMapIterator.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/iterators/AbstractTestOrderedMapIterator.java b/src/test/org/apache/commons/collections/iterators/AbstractTestOrderedMapIterator.java
index 2b47647..a099be5 100644
--- a/src/test/org/apache/commons/collections/iterators/AbstractTestOrderedMapIterator.java
+++ b/src/test/org/apache/commons/collections/iterators/AbstractTestOrderedMapIterator.java
@@ -5,9 +5,9 @@
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -33,17 +33,17 @@ import org.apache.commons.collections.OrderedMapIterator;
* Concrete subclasses must provide the list iterator to be tested.
* They must also specify certain details of how the list iterator operates by
* overriding the supportsXxx() methods if necessary.
- *
+ *
* @since Commons Collections 3.0
* @version $Revision$ $Date$
- *
+ *
* @author Stephen Colebourne
*/
-public abstract class AbstractTestOrderedMapIterator extends AbstractTestMapIterator {
+public abstract class AbstractTestOrderedMapIterator<K, V> extends AbstractTestMapIterator<K, V> {
/**
* JUnit constructor.
- *
+ *
* @param testName the test class name
*/
public AbstractTestOrderedMapIterator(String testName) {
@@ -51,14 +51,10 @@ public abstract class AbstractTestOrderedMapIterator extends AbstractTestMapIter
}
//-----------------------------------------------------------------------
- public final OrderedMapIterator makeEmptyOrderedMapIterator() {
- return (OrderedMapIterator) makeEmptyMapIterator();
- }
+ public abstract OrderedMapIterator<K, V> makeEmptyIterator();
+
+ public abstract OrderedMapIterator<K, V> makeObject();
- public final OrderedMapIterator makeFullOrderedMapIterator() {
- return (OrderedMapIterator) makeFullMapIterator();
- }
-
//-----------------------------------------------------------------------
/**
* Test that the empty list iterator contract is correct.
@@ -69,9 +65,8 @@ public abstract class AbstractTestOrderedMapIterator extends AbstractTestMapIter
}
super.testEmptyMapIterator();
-
- OrderedMapIterator it = makeEmptyOrderedMapIterator();
- Map map = getMap();
+
+ OrderedMapIterator<K, V> it = makeEmptyIterator();
assertEquals(false, it.hasPrevious());
try {
it.previous();
@@ -89,29 +84,29 @@ public abstract class AbstractTestOrderedMapIterator extends AbstractTestMapIter
}
super.testFullMapIterator();
-
- OrderedMapIterator it = makeFullOrderedMapIterator();
- Map map = getMap();
-
+
+ OrderedMapIterator<K, V> it = makeObject();
+ Map<K, V> map = getMap();
+
assertEquals(true, it.hasNext());
assertEquals(false, it.hasPrevious());
- Set set = new HashSet();
+ Set<K> set = new HashSet<K>();
while (it.hasNext()) {
// getKey
- Object key = it.next();
+ K key = it.next();
assertSame("it.next() should equals getKey()", key, it.getKey());
assertTrue("Key must be in map", map.containsKey(key));
assertTrue("Key must be unique", set.add(key));
-
+
// getValue
- Object value = it.getValue();
+ V value = it.getValue();
if (isGetStructuralModify() == false) {
assertSame("Value must be mapped to key", map.get(key), value);
}
assertTrue("Value must be in map", map.containsValue(value));
assertEquals(true, it.hasPrevious());
-
+
verify();
}
while (it.hasPrevious()) {
@@ -120,7 +115,7 @@ public abstract class AbstractTestOrderedMapIterator extends AbstractTestMapIter
assertSame("it.previous() should equals getKey()", key, it.getKey());
assertTrue("Key must be in map", map.containsKey(key));
assertTrue("Key must be unique", set.remove(key));
-
+
// getValue
Object value = it.getValue();
if (isGetStructuralModify() == false) {
@@ -129,11 +124,11 @@ public abstract class AbstractTestOrderedMapIterator extends AbstractTestMapIter
assertTrue("Value must be in map", map.containsValue(value));
assertEquals(true, it.hasNext());
-
+
verify();
}
}
-
+
//-----------------------------------------------------------------------
/**
* Test that the iterator order matches the keySet order.
@@ -143,27 +138,27 @@ public abstract class AbstractTestOrderedMapIterator extends AbstractTestMapIter
return;
}
- OrderedMapIterator it = makeFullOrderedMapIterator();
- Map map = getMap();
-
- assertEquals("keySet() not consistent", new ArrayList(map.keySet()), new ArrayList(map.keySet()));
-
- Iterator it2 = map.keySet().iterator();
+ OrderedMapIterator<K, V> it = makeObject();
+ Map<K, V> map = getMap();
+
+ assertEquals("keySet() not consistent", new ArrayList<K>(map.keySet()), new ArrayList<K>(map.keySet()));
+
+ Iterator<K> it2 = map.keySet().iterator();
assertEquals(true, it.hasNext());
assertEquals(true, it2.hasNext());
- List list = new ArrayList();
+ List<K> list = new ArrayList<K>();
while (it.hasNext()) {
- Object key = it.next();
+ K key = it.next();
assertEquals(it2.next(), key);
list.add(key);
}
assertEquals(map.size(), list.size());
while (it.hasPrevious()) {
- Object key = it.previous();
+ K key = it.previous();
assertEquals(list.get(list.size() - 1), key);
list.remove(list.size() - 1);
}
assertEquals(0, list.size());
}
-
+
}
http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/iterators/TestArrayIterator.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/iterators/TestArrayIterator.java b/src/test/org/apache/commons/collections/iterators/TestArrayIterator.java
index 6307740..44a3efc 100644
--- a/src/test/org/apache/commons/collections/iterators/TestArrayIterator.java
+++ b/src/test/org/apache/commons/collections/iterators/TestArrayIterator.java
@@ -34,7 +34,7 @@ import junit.framework.TestSuite;
* @author Morgan Delagrange
* @author Stephen Colebourne
*/
-public class TestArrayIterator extends AbstractTestIterator {
+public class TestArrayIterator<E> extends AbstractTestIterator<E> {
protected String[] testArray = { "One", "Two", "Three" };
@@ -46,24 +46,23 @@ public class TestArrayIterator extends AbstractTestIterator {
super(testName);
}
- public Iterator makeEmptyIterator() {
- return new ArrayIterator(new Object[0]);
+ public ArrayIterator<E> makeEmptyIterator() {
+ return new ArrayIterator<E>(new Object[0]);
}
- public Iterator makeFullIterator() {
- return new ArrayIterator(testArray);
+ public ArrayIterator<E> makeObject() {
+ return new ArrayIterator<E>(testArray);
}
public boolean supportsRemove() {
return false;
}
-
public void testIterator() {
- Iterator iter = (Iterator) makeFullIterator();
+ Iterator<E> iter = makeObject();
for (int i = 0; i < testArray.length; i++) {
Object testValue = testArray[i];
- Object iterValue = iter.next();
+ E iterValue = iter.next();
assertEquals("Iteration value is correct", testValue, iterValue);
}
@@ -71,7 +70,7 @@ public class TestArrayIterator extends AbstractTestIterator {
assertTrue("Iterator should now be empty", !iter.hasNext());
try {
- Object testValue = iter.next();
+ iter.next();
} catch (Exception e) {
assertTrue(
"NoSuchElementException must be thrown",
@@ -81,14 +80,13 @@ public class TestArrayIterator extends AbstractTestIterator {
public void testNullArray() {
try {
- Iterator iter = new ArrayIterator(null);
-
+ new ArrayIterator<Object>(null);
fail("Constructor should throw a NullPointerException when constructed with a null array");
} catch (NullPointerException e) {
// expected
}
- ArrayIterator iter = new ArrayIterator();
+ ArrayIterator<Object> iter = new ArrayIterator<Object>();
try {
iter.setArray(null);
@@ -99,7 +97,7 @@ public class TestArrayIterator extends AbstractTestIterator {
}
public void testReset() {
- ArrayIterator it = (ArrayIterator) makeFullIterator();
+ ArrayIterator<E> it = makeObject();
it.next();
it.reset();
assertEquals("One", it.next());
http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/iterators/TestArrayIterator2.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/iterators/TestArrayIterator2.java b/src/test/org/apache/commons/collections/iterators/TestArrayIterator2.java
index c4423cf..975c37b 100644
--- a/src/test/org/apache/commons/collections/iterators/TestArrayIterator2.java
+++ b/src/test/org/apache/commons/collections/iterators/TestArrayIterator2.java
@@ -5,9 +5,9 @@
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -24,13 +24,13 @@ import junit.framework.TestSuite;
/**
* Tests the ArrayIterator with primitive type arrays.
- *
+ *
* @version $Revision$ $Date$
- *
+ *
* @author Morgan Delagrange
* @author James Strachan
*/
-public class TestArrayIterator2 extends AbstractTestIterator {
+public class TestArrayIterator2<E> extends AbstractTestIterator<E> {
protected int[] testArray = { 2, 4, 6, 8 };
@@ -42,41 +42,32 @@ public class TestArrayIterator2 extends AbstractTestIterator {
super(testName);
}
- public Iterator makeEmptyIterator() {
- return new ArrayIterator(new int[0]);
+ public ArrayIterator<E> makeEmptyIterator() {
+ return new ArrayIterator<E>(new int[0]);
}
- public Iterator makeFullIterator() {
- return new ArrayIterator(testArray);
+ public ArrayIterator<E> makeObject() {
+ return new ArrayIterator<E>(testArray);
}
- /*
- * We use these <code>makeArrayIterator</code> factory methods instead of
- * directly calling the constructor so as to allow subclasses
- * (e.g. TestArrayListIterator2) to use the existing test code.
- *
- * @return ArrayIterator
- */
- public ArrayIterator makeArrayIterator() {
- return (ArrayIterator) makeEmptyIterator();
+ public ArrayIterator<E> makeArrayIterator(Object array) {
+ return new ArrayIterator<E>(array);
}
- public ArrayIterator makeArrayIterator(Object array) {
- return new ArrayIterator(array);
- }
- public ArrayIterator makeArrayIterator(Object array, int index) {
- return new ArrayIterator(array, index);
+
+ public ArrayIterator<E> makeArrayIterator(Object array, int index) {
+ return new ArrayIterator<E>(array, index);
}
- public ArrayIterator makeArrayIterator(Object array, int start, int end) {
- return new ArrayIterator(array, start, end);
+
+ public ArrayIterator<E> makeArrayIterator(Object array, int start, int end) {
+ return new ArrayIterator<E>(array, start, end);
}
public boolean supportsRemove() {
return false;
}
-
public void testIterator() {
- Iterator iter = (Iterator) makeFullIterator();
+ Iterator<E> iter = makeObject();
for (int i = 0; i < testArray.length; i++) {
Integer testValue = new Integer(testArray[i]);
Number iterValue = (Number) iter.next();
@@ -87,7 +78,7 @@ public class TestArrayIterator2 extends AbstractTestIterator {
assertTrue("Iterator should now be empty", !iter.hasNext());
try {
- Object testValue = iter.next();
+ iter.next();
} catch (Exception e) {
assertTrue(
"NoSuchElementException must be thrown",
@@ -96,9 +87,9 @@ public class TestArrayIterator2 extends AbstractTestIterator {
}
// proves that an ArrayIterator set with the constructor has the same number of elements
- // as an ArrayIterator set with setArray(Object)
+ // as an ArrayIterator set with setArray(Object)
public void testSetArray() {
- Iterator iter1 = makeArrayIterator(testArray);
+ Iterator<E> iter1 = makeArrayIterator(testArray);
int count1 = 0;
while (iter1.hasNext()) {
++count1;
@@ -107,7 +98,7 @@ public class TestArrayIterator2 extends AbstractTestIterator {
assertEquals("the count should be right using the constructor", count1, testArray.length);
- ArrayIterator iter2 = makeArrayIterator();
+ ArrayIterator<E> iter2 = makeObject();
iter2.setArray(testArray);
int count2 = 0;
while (iter2.hasNext()) {
@@ -119,7 +110,7 @@ public class TestArrayIterator2 extends AbstractTestIterator {
}
public void testIndexedArray() {
- Iterator iter = makeArrayIterator(testArray, 2);
+ Iterator<E> iter = makeArrayIterator(testArray, 2);
int count = 0;
while (iter.hasNext()) {
++count;
http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/iterators/TestArrayListIterator.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/iterators/TestArrayListIterator.java b/src/test/org/apache/commons/collections/iterators/TestArrayListIterator.java
index a51eb21..1c70fe2 100644
--- a/src/test/org/apache/commons/collections/iterators/TestArrayListIterator.java
+++ b/src/test/org/apache/commons/collections/iterators/TestArrayListIterator.java
@@ -17,7 +17,6 @@
package org.apache.commons.collections.iterators;
import java.util.Arrays;
-import java.util.Iterator;
import java.util.ListIterator;
import java.util.NoSuchElementException;
@@ -30,7 +29,7 @@ import junit.framework.TestSuite;
* @version $Revision$ $Date$
* @author Neil O'Toole
*/
-public class TestArrayListIterator extends TestArrayIterator {
+public class TestArrayListIterator<E> extends TestArrayIterator<E> {
public TestArrayListIterator(String testName) {
super(testName);
@@ -40,16 +39,16 @@ public class TestArrayListIterator extends TestArrayIterator {
return new TestSuite(TestArrayListIterator.class);
}
- public Iterator makeEmptyIterator() {
- return new ArrayListIterator(new Object[0]);
+ public ArrayListIterator<E> makeEmptyIterator() {
+ return new ArrayListIterator<E>(new Object[0]);
}
- public Iterator makeFullIterator() {
- return new ArrayListIterator(testArray);
+ public ArrayListIterator<E> makeObject() {
+ return new ArrayListIterator<E>(testArray);
}
- public ListIterator makeArrayListIterator(Object array) {
- return new ArrayListIterator(array);
+ public ArrayListIterator<E> makeArrayListIterator(Object array) {
+ return new ArrayListIterator<E>(array);
}
public boolean supportsRemove() {
@@ -61,7 +60,7 @@ public class TestArrayListIterator extends TestArrayIterator {
* <code>previous()</code>.
*/
public void testListIterator() {
- ListIterator iter = (ListIterator) makeFullIterator();
+ ListIterator<E> iter = makeObject();
// TestArrayIterator#testIterator() has already tested the iterator forward,
// now we need to test it in reverse
@@ -81,7 +80,7 @@ public class TestArrayListIterator extends TestArrayIterator {
assertTrue("Iterator should now be empty", !iter.hasPrevious());
try {
- Object testValue = iter.previous();
+ iter.previous();
} catch (Exception e) {
assertTrue(
"NoSuchElementException must be thrown",
@@ -93,17 +92,18 @@ public class TestArrayListIterator extends TestArrayIterator {
/**
* Tests the {@link java.util.ListIterator#set} operation.
*/
+ @SuppressWarnings("unchecked")
public void testListIteratorSet() {
String[] testData = new String[] { "a", "b", "c" };
String[] result = new String[] { "0", "1", "2" };
- ListIterator iter = (ListIterator) makeArrayListIterator(testData);
+ ListIterator<E> iter = makeArrayListIterator(testData);
int x = 0;
while (iter.hasNext()) {
iter.next();
- iter.set(Integer.toString(x));
+ iter.set((E) Integer.toString(x));
x++;
}
@@ -113,7 +113,7 @@ public class TestArrayListIterator extends TestArrayIterator {
iter = makeArrayListIterator(testArray);
try {
- iter.set("should fail");
+ iter.set((E) "should fail");
fail("ListIterator#set should fail if next() or previous() have not yet been called.");
} catch (IllegalStateException e) {
// expected
http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/iterators/TestArrayListIterator2.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/iterators/TestArrayListIterator2.java b/src/test/org/apache/commons/collections/iterators/TestArrayListIterator2.java
index 86efe8f..cb2ea8c 100644
--- a/src/test/org/apache/commons/collections/iterators/TestArrayListIterator2.java
+++ b/src/test/org/apache/commons/collections/iterators/TestArrayListIterator2.java
@@ -16,8 +16,6 @@
*/
package org.apache.commons.collections.iterators;
-import java.util.Iterator;
-
import junit.framework.Test;
import junit.framework.TestSuite;
@@ -27,7 +25,7 @@ import junit.framework.TestSuite;
* @version $Revision$ $Date$
* @author Neil O'Toole
*/
-public class TestArrayListIterator2 extends TestArrayIterator2 {
+public class TestArrayListIterator2<E> extends TestArrayIterator2<E> {
public TestArrayListIterator2(String testName) {
super(testName);
@@ -37,28 +35,24 @@ public class TestArrayListIterator2 extends TestArrayIterator2 {
return new TestSuite(TestArrayListIterator2.class);
}
- public Iterator makeEmptyIterator() {
- return new ArrayListIterator(new int[0]);
- }
-
- public Iterator makeFullIterator() {
- return new ArrayListIterator(testArray);
+ public ArrayListIterator<E> makeEmptyIterator() {
+ return new ArrayListIterator<E>(new int[0]);
}
- public ArrayIterator makeArrayIterator() {
- return (ArrayIterator) makeEmptyIterator();
+ public ArrayListIterator<E> makeObject() {
+ return new ArrayListIterator<E>(testArray);
}
- public ArrayIterator makeArrayIterator(Object array) {
- return new ArrayListIterator(array);
+ public ArrayListIterator<E> makeArrayListIterator(Object array) {
+ return new ArrayListIterator<E>(array);
}
- public ArrayIterator makeArrayIterator(Object array, int index) {
- return new ArrayListIterator(array, index);
+ public ArrayListIterator<E> makeArrayListIterator(Object array, int index) {
+ return new ArrayListIterator<E>(array, index);
}
- public ArrayIterator makeArrayIterator(Object array, int start, int end) {
- return new ArrayListIterator(array, start, end);
+ public ArrayListIterator<E> makeArrayListIterator(Object array, int start, int end) {
+ return new ArrayListIterator<E>(array, start, end);
}
}
http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/iterators/TestCollatingIterator.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/iterators/TestCollatingIterator.java b/src/test/org/apache/commons/collections/iterators/TestCollatingIterator.java
index 2440d23..789576c 100644
--- a/src/test/org/apache/commons/collections/iterators/TestCollatingIterator.java
+++ b/src/test/org/apache/commons/collections/iterators/TestCollatingIterator.java
@@ -5,9 +5,9 @@
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -18,7 +18,6 @@ package org.apache.commons.collections.iterators;
import java.util.ArrayList;
import java.util.Comparator;
-import java.util.Iterator;
import junit.framework.Test;
import junit.framework.TestSuite;
@@ -27,60 +26,60 @@ import org.apache.commons.collections.comparators.ComparableComparator;
/**
* Unit test suite for {@link CollatingIterator}.
- *
+ *
* @version $Revision$ $Date$
* @author Rodney Waldhoff
*/
-public class TestCollatingIterator extends AbstractTestIterator {
+public class TestCollatingIterator extends AbstractTestIterator<Integer> {
//------------------------------------------------------------ Conventional
-
+
public TestCollatingIterator(String testName) {
super(testName);
}
-
+
public static Test suite() {
return new TestSuite(TestCollatingIterator.class);
}
//--------------------------------------------------------------- Lifecycle
- private Comparator comparator = null;
- private ArrayList evens = null;
- private ArrayList odds = null;
- private ArrayList fib = null;
+ private Comparator<Integer> comparator = null;
+ private ArrayList<Integer> evens = null;
+ private ArrayList<Integer> odds = null;
+ private ArrayList<Integer> fib = null;
public void setUp() throws Exception {
super.setUp();
- comparator = new ComparableComparator();
- evens = new ArrayList();
- odds = new ArrayList();
- for(int i=0;i<20;i++) {
- if(0 == i%2) {
- evens.add(new Integer(i));
+ comparator = new ComparableComparator<Integer>();
+ evens = new ArrayList<Integer>();
+ odds = new ArrayList<Integer>();
+ for (int i = 0; i < 20; i++) {
+ if (0 == i % 2) {
+ evens.add(i);
} else {
- odds.add(new Integer(i));
+ odds.add(i);
}
}
- fib = new ArrayList();
- fib.add(new Integer(1));
- fib.add(new Integer(1));
- fib.add(new Integer(2));
- fib.add(new Integer(3));
- fib.add(new Integer(5));
- fib.add(new Integer(8));
- fib.add(new Integer(13));
- fib.add(new Integer(21));
- }
+ fib = new ArrayList<Integer>();
+ fib.add(1);
+ fib.add(1);
+ fib.add(2);
+ fib.add(3);
+ fib.add(5);
+ fib.add(8);
+ fib.add(13);
+ fib.add(21);
+ }
//---------------------------------------------------- TestIterator Methods
-
- public Iterator makeEmptyIterator() {
- return new CollatingIterator(comparator);
+
+ public CollatingIterator<Integer> makeEmptyIterator() {
+ return new CollatingIterator<Integer>(comparator);
}
- public Iterator makeFullIterator() {
- CollatingIterator iter = new CollatingIterator(comparator);
+ public CollatingIterator<Integer> makeObject() {
+ CollatingIterator<Integer> iter = new CollatingIterator<Integer>(comparator);
iter.addIterator(evens.iterator());
iter.addIterator(odds.iterator());
iter.addIterator(fib.iterator());
@@ -90,36 +89,36 @@ public class TestCollatingIterator extends AbstractTestIterator {
//------------------------------------------------------------------- Tests
public void testGetSetComparator() {
- CollatingIterator iter = new CollatingIterator();
+ CollatingIterator<Integer> iter = new CollatingIterator<Integer>();
assertNull(iter.getComparator());
iter.setComparator(comparator);
- assertSame(comparator,iter.getComparator());
+ assertSame(comparator, iter.getComparator());
iter.setComparator(null);
assertNull(iter.getComparator());
}
public void testIterateEven() {
- CollatingIterator iter = new CollatingIterator(comparator);
+ CollatingIterator<Integer> iter = new CollatingIterator<Integer>(comparator);
iter.addIterator(evens.iterator());
- for(int i=0;i<evens.size();i++) {
+ for (int i = 0; i < evens.size(); i++) {
assertTrue(iter.hasNext());
- assertEquals(evens.get(i),iter.next());
+ assertEquals(evens.get(i), iter.next());
}
assertTrue(!iter.hasNext());
}
public void testIterateEvenOdd() {
- CollatingIterator iter = new CollatingIterator(comparator,evens.iterator(),odds.iterator());
- for(int i=0;i<20;i++) {
+ CollatingIterator<Integer> iter = new CollatingIterator<Integer>(comparator, evens.iterator(), odds.iterator());
+ for (int i = 0; i < 20; i++) {
assertTrue(iter.hasNext());
- assertEquals(new Integer(i),iter.next());
+ assertEquals(new Integer(i), iter.next());
}
assertTrue(!iter.hasNext());
}
public void testIterateOddEven() {
- CollatingIterator iter = new CollatingIterator(comparator,odds.iterator(),evens.iterator());
- for(int i=0;i<20;i++) {
+ CollatingIterator<Integer> iter = new CollatingIterator<Integer>(comparator, odds.iterator(), evens.iterator());
+ for (int i = 0; i < 20; i++) {
assertTrue(iter.hasNext());
assertEquals(new Integer(i),iter.next());
}
@@ -127,25 +126,24 @@ public class TestCollatingIterator extends AbstractTestIterator {
}
public void testIterateEvenEven() {
- CollatingIterator iter = new CollatingIterator(comparator);
+ CollatingIterator<Integer> iter = new CollatingIterator<Integer>(comparator);
iter.addIterator(evens.iterator());
iter.addIterator(evens.iterator());
- for(int i=0;i<evens.size();i++) {
+ for (int i = 0; i < evens.size(); i++) {
assertTrue(iter.hasNext());
- assertEquals(evens.get(i),iter.next());
+ assertEquals(evens.get(i), iter.next());
assertTrue(iter.hasNext());
- assertEquals(evens.get(i),iter.next());
+ assertEquals(evens.get(i), iter.next());
}
assertTrue(!iter.hasNext());
}
-
public void testIterateFibEvenOdd() {
- CollatingIterator iter = new CollatingIterator(comparator);
+ CollatingIterator<Integer> iter = new CollatingIterator<Integer>(comparator);
iter.addIterator(fib.iterator());
iter.addIterator(evens.iterator());
iter.addIterator(odds.iterator());
-
+
assertEquals(new Integer(0),iter.next()); // even 0
assertEquals(new Integer(1),iter.next()); // fib 1
assertEquals(new Integer(1),iter.next()); // fib 1
@@ -179,12 +177,13 @@ public class TestCollatingIterator extends AbstractTestIterator {
}
public void testRemoveFromSingle() {
- CollatingIterator iter = new CollatingIterator(comparator);
+ CollatingIterator<Integer> iter = new CollatingIterator<Integer>(comparator);
iter.addIterator(evens.iterator());
int expectedSize = evens.size();
- while(iter.hasNext()) {
- Integer val = (Integer)(iter.next());
- if(val.intValue() % 4 == 0) {
+ while (iter.hasNext()) {
+ Object o = iter.next();
+ Integer val = (Integer) o;
+ if (val.intValue() % 4 == 0) {
expectedSize--;
iter.remove();
}
@@ -193,19 +192,20 @@ public class TestCollatingIterator extends AbstractTestIterator {
}
public void testRemoveFromDouble() {
- CollatingIterator iter = new CollatingIterator(comparator);
+ CollatingIterator<Integer> iter = new CollatingIterator<Integer>(comparator);
iter.addIterator(evens.iterator());
iter.addIterator(odds.iterator());
int expectedSize = evens.size() + odds.size();
- while(iter.hasNext()) {
- Integer val = (Integer)(iter.next());
- if(val.intValue() % 4 == 0 || val.intValue() % 3 == 0 ) {
+ while (iter.hasNext()) {
+ Object o = iter.next();
+ Integer val = (Integer) o;
+ if (val.intValue() % 4 == 0 || val.intValue() % 3 == 0) {
expectedSize--;
iter.remove();
}
}
- assertEquals(expectedSize,(evens.size() + odds.size()));
- }
+ assertEquals(expectedSize, (evens.size() + odds.size()));
+ }
}
http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/iterators/TestFilterIterator.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/iterators/TestFilterIterator.java b/src/test/org/apache/commons/collections/iterators/TestFilterIterator.java
index 1665a2d..9020153 100644
--- a/src/test/org/apache/commons/collections/iterators/TestFilterIterator.java
+++ b/src/test/org/apache/commons/collections/iterators/TestFilterIterator.java
@@ -5,9 +5,9 @@
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -30,18 +30,17 @@ import junit.framework.TestSuite;
import org.apache.commons.collections.Predicate;
import org.apache.commons.collections.functors.NotNullPredicate;
-import org.apache.commons.collections.functors.TruePredicate;
/**
* Test the filter iterator.
*
* @version $Revision$ $Date$
- *
+ *
* @author Jan Sorensen
* @author Ralph Wagner
* @author Huw Roberts
*/
-public class TestFilterIterator extends AbstractTestIterator {
+public class TestFilterIterator<E> extends AbstractTestIterator<E> {
/** Creates new TestFilterIterator */
public TestFilterIterator(String name) {
@@ -49,8 +48,9 @@ public class TestFilterIterator extends AbstractTestIterator {
}
private String[] array;
- private List list;
- private FilterIterator iterator;
+ private List<E> list;
+ private FilterIterator<E> iterator;
+
/**
* Set up instance variables required by this test case.
*/
@@ -76,22 +76,22 @@ public class TestFilterIterator extends AbstractTestIterator {
/**
* Returns an full iterator wrapped in a
* FilterIterator that blocks all the elements
- *
+ *
* @return "empty" FilterIterator
*/
- public Iterator makeEmptyIterator() {
- return makeBlockAllFilter(new ArrayIterator(array));
+ public FilterIterator<E> makeEmptyIterator() {
+ return makeBlockAllFilter(new ArrayIterator<E>(array));
}
/**
* Returns an array with elements wrapped in a pass-through
* FilterIterator
- *
- * @return
+ *
+ * @return
*/
- public Iterator makeFullIterator() {
- array = new String[] { "a", "b", "c" };
- list = new ArrayList(Arrays.asList(array));
+ @SuppressWarnings("unchecked")
+ public FilterIterator<E> makeObject() {
+ list = new ArrayList<E>(Arrays.asList((E[]) array));
return makePassThroughFilter(list.iterator());
}
@@ -102,8 +102,9 @@ public class TestFilterIterator extends AbstractTestIterator {
}
public void testRepeatedNext() {
- for (int i = 0; i < array.length; i++)
+ for (int i = 0; i < array.length; i++) {
iterator.next();
+ }
verifyNoMoreElements();
}
@@ -122,15 +123,16 @@ public class TestFilterIterator extends AbstractTestIterator {
* Test that when the iterator is changed, the hasNext method returns the
* correct response for the new iterator.
*/
+ @SuppressWarnings("unchecked")
public void testSetIterator() {
- Iterator iter1 = Collections.singleton(new Object()).iterator();
- Iterator iter2 = Collections.EMPTY_LIST.iterator();
-
- FilterIterator filterIterator = new FilterIterator(iter1);
+ Iterator<E> iter1 = Collections.singleton((E) new Object()).iterator();
+ Iterator<E> iter2 = Collections.<E>emptyList().iterator();
+
+ FilterIterator<E> filterIterator = new FilterIterator<E>(iter1);
filterIterator.setPredicate(truePredicate());
// this iterator has elements
assertEquals(true, filterIterator.hasNext());
-
+
// this iterator has no elements
filterIterator.setIterator(iter2);
assertEquals(false, filterIterator.hasNext());
@@ -141,13 +143,13 @@ public class TestFilterIterator extends AbstractTestIterator {
* correct response for the new predicate.
*/
public void testSetPredicate() {
- Iterator iter = Collections.singleton(null).iterator();
+ Iterator<E> iter = Collections.singleton((E) null).iterator();
- FilterIterator filterIterator = new FilterIterator(iter);
+ FilterIterator<E> filterIterator = new FilterIterator<E>(iter);
filterIterator.setPredicate(truePredicate());
// this predicate matches
assertEquals(true, filterIterator.hasNext());
-
+
// this predicate doesn't match
filterIterator.setPredicate(NotNullPredicate.getInstance());
assertEquals(false, filterIterator.hasNext());
@@ -165,11 +167,13 @@ public class TestFilterIterator extends AbstractTestIterator {
}
private void verifyElementsInPredicate(final String[] elements) {
- Predicate pred = new Predicate() {
- public boolean evaluate(Object x) {
- for (int i = 0; i < elements.length; i++)
- if (elements[i].equals(x))
+ Predicate<E> pred = new Predicate<E>() {
+ public boolean evaluate(E x) {
+ for (int i = 0; i < elements.length; i++) {
+ if (elements[i].equals(x)) {
return true;
+ }
+ }
return false;
}
};
@@ -193,35 +197,35 @@ public class TestFilterIterator extends AbstractTestIterator {
}
private void initIterator() {
- iterator = (FilterIterator) makeFullIterator();
+ iterator = makeObject();
}
/**
* Returns a FilterIterator that does not filter
* any of its elements
- *
+ *
* @param i the Iterator to "filter"
* @return "filtered" iterator
*/
- protected FilterIterator makePassThroughFilter(Iterator i) {
- Predicate pred = new Predicate() {
- public boolean evaluate(Object x) { return true; }
+ protected FilterIterator<E> makePassThroughFilter(Iterator<E> i) {
+ Predicate<E> pred = new Predicate<E>() {
+ public boolean evaluate(E x) { return true; }
};
- return new FilterIterator(i,pred);
+ return new FilterIterator<E>(i, pred);
}
/**
* Returns a FilterIterator that blocks
* all of its elements
- *
+ *
* @param i the Iterator to "filter"
* @return "filtered" iterator
*/
- protected FilterIterator makeBlockAllFilter(Iterator i) {
- Predicate pred = new Predicate() {
- public boolean evaluate(Object x) { return false; }
+ protected FilterIterator<E> makeBlockAllFilter(Iterator<E> i) {
+ Predicate<E> pred = new Predicate<E>() {
+ public boolean evaluate(E x) { return false; }
};
- return new FilterIterator(i,pred);
+ return new FilterIterator<E>(i, pred);
}
}
http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/iterators/TestFilterListIterator.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/iterators/TestFilterListIterator.java b/src/test/org/apache/commons/collections/iterators/TestFilterListIterator.java
index 1597a4e..e0bab72 100644
--- a/src/test/org/apache/commons/collections/iterators/TestFilterListIterator.java
+++ b/src/test/org/apache/commons/collections/iterators/TestFilterListIterator.java
@@ -48,69 +48,69 @@ public class TestFilterListIterator extends TestCase {
junit.textui.TestRunner.main(testCaseName);
}
- private ArrayList list = null;
- private ArrayList odds = null;
- private ArrayList evens = null;
- private ArrayList threes = null;
- private ArrayList fours = null;
- private ArrayList sixes = null;
- private Predicate truePred = null;
- private Predicate falsePred = null;
- private Predicate evenPred = null;
- private Predicate oddPred = null;
- private Predicate threePred = null;
- private Predicate fourPred = null;
+ private ArrayList<Integer> list = null;
+ private ArrayList<Integer> odds = null;
+ private ArrayList<Integer> evens = null;
+ private ArrayList<Integer> threes = null;
+ private ArrayList<Integer> fours = null;
+ private ArrayList<Integer> sixes = null;
+ private Predicate<Integer> truePred = null;
+ private Predicate<Integer> falsePred = null;
+ private Predicate<Integer> evenPred = null;
+ private Predicate<Integer> oddPred = null;
+ private Predicate<Integer> threePred = null;
+ private Predicate<Integer> fourPred = null;
private Random random = new Random();
public void setUp() {
- list = new ArrayList();
- odds = new ArrayList();
- evens = new ArrayList();
- threes = new ArrayList();
- fours = new ArrayList();
- sixes = new ArrayList();
- for(int i=0;i<20;i++) {
+ list = new ArrayList<Integer>();
+ odds = new ArrayList<Integer>();
+ evens = new ArrayList<Integer>();
+ threes = new ArrayList<Integer>();
+ fours = new ArrayList<Integer>();
+ sixes = new ArrayList<Integer>();
+ for (int i = 0; i < 20; i++) {
list.add(new Integer(i));
- if(i%2 == 0) { evens.add(new Integer(i)); }
- if(i%2 == 1) { odds.add(new Integer(i)); }
- if(i%3 == 0) { threes.add(new Integer(i)); }
- if(i%4 == 0) { fours.add(new Integer(i)); }
- if(i%6 == 0) { sixes.add(new Integer(i)); }
+ if (i % 2 == 0) { evens.add(new Integer(i)); }
+ if (i % 2 == 1) { odds.add(new Integer(i)); }
+ if (i % 3 == 0) { threes.add(new Integer(i)); }
+ if (i % 4 == 0) { fours.add(new Integer(i)); }
+ if (i % 6 == 0) { sixes.add(new Integer(i)); }
}
- truePred = new Predicate() {
- public boolean evaluate(Object x) {
+ truePred = new Predicate<Integer>() {
+ public boolean evaluate(Integer x) {
return true;
}
};
- falsePred = new Predicate() {
- public boolean evaluate(Object x) {
+ falsePred = new Predicate<Integer>() {
+ public boolean evaluate(Integer x) {
return true;
}
};
- evenPred = new Predicate() {
- public boolean evaluate(Object x) {
- return (((Integer)x).intValue()%2 == 0);
+ evenPred = new Predicate<Integer>() {
+ public boolean evaluate(Integer x) {
+ return x % 2 == 0;
}
};
- oddPred = new Predicate() {
- public boolean evaluate(Object x) {
- return (((Integer)x).intValue()%2 == 1);
+ oddPred = new Predicate<Integer>() {
+ public boolean evaluate(Integer x) {
+ return x % 2 == 1;
}
};
- threePred = new Predicate() {
- public boolean evaluate(Object x) {
- return (((Integer)x).intValue()%3 == 0);
+ threePred = new Predicate<Integer>() {
+ public boolean evaluate(Integer x) {
+ return x % 3 == 0;
}
};
- fourPred = new Predicate() {
- public boolean evaluate(Object x) {
- return (((Integer)x).intValue()%4 == 0);
+ fourPred = new Predicate<Integer>() {
+ public boolean evaluate(Integer x) {
+ return x % 4 == 0;
}
};
@@ -138,208 +138,207 @@ public class TestFilterListIterator extends TestCase {
public void testManual() {
// do this one "by hand" as a sanity check
- FilterListIterator filtered = new FilterListIterator(list.listIterator(),threePred);
+ FilterListIterator<Integer> filtered = new FilterListIterator<Integer>(list.listIterator(), threePred);
- assertEquals(new Integer(0),filtered.next());
- assertEquals(new Integer(3),filtered.next());
- assertEquals(new Integer(6),filtered.next());
- assertEquals(new Integer(9),filtered.next());
- assertEquals(new Integer(12),filtered.next());
- assertEquals(new Integer(15),filtered.next());
- assertEquals(new Integer(18),filtered.next());
-
- assertEquals(new Integer(18),filtered.previous());
- assertEquals(new Integer(15),filtered.previous());
- assertEquals(new Integer(12),filtered.previous());
- assertEquals(new Integer(9),filtered.previous());
- assertEquals(new Integer(6),filtered.previous());
- assertEquals(new Integer(3),filtered.previous());
- assertEquals(new Integer(0),filtered.previous());
+ assertEquals(new Integer(0), filtered.next());
+ assertEquals(new Integer(3), filtered.next());
+ assertEquals(new Integer(6), filtered.next());
+ assertEquals(new Integer(9), filtered.next());
+ assertEquals(new Integer(12), filtered.next());
+ assertEquals(new Integer(15), filtered.next());
+ assertEquals(new Integer(18), filtered.next());
+
+ assertEquals(new Integer(18), filtered.previous());
+ assertEquals(new Integer(15), filtered.previous());
+ assertEquals(new Integer(12), filtered.previous());
+ assertEquals(new Integer(9), filtered.previous());
+ assertEquals(new Integer(6), filtered.previous());
+ assertEquals(new Integer(3), filtered.previous());
+ assertEquals(new Integer(0), filtered.previous());
assertTrue(!filtered.hasPrevious());
- assertEquals(new Integer(0),filtered.next());
- assertEquals(new Integer(3),filtered.next());
- assertEquals(new Integer(6),filtered.next());
- assertEquals(new Integer(9),filtered.next());
- assertEquals(new Integer(12),filtered.next());
- assertEquals(new Integer(15),filtered.next());
- assertEquals(new Integer(18),filtered.next());
+ assertEquals(new Integer(0), filtered.next());
+ assertEquals(new Integer(3), filtered.next());
+ assertEquals(new Integer(6), filtered.next());
+ assertEquals(new Integer(9), filtered.next());
+ assertEquals(new Integer(12), filtered.next());
+ assertEquals(new Integer(15), filtered.next());
+ assertEquals(new Integer(18), filtered.next());
assertTrue(!filtered.hasNext());
- assertEquals(new Integer(18),filtered.previous());
- assertEquals(new Integer(15),filtered.previous());
- assertEquals(new Integer(12),filtered.previous());
- assertEquals(new Integer(9),filtered.previous());
- assertEquals(new Integer(6),filtered.previous());
- assertEquals(new Integer(3),filtered.previous());
- assertEquals(new Integer(0),filtered.previous());
-
- assertEquals(new Integer(0),filtered.next());
- assertEquals(new Integer(0),filtered.previous());
- assertEquals(new Integer(0),filtered.next());
-
- assertEquals(new Integer(3),filtered.next());
- assertEquals(new Integer(6),filtered.next());
- assertEquals(new Integer(6),filtered.previous());
- assertEquals(new Integer(3),filtered.previous());
- assertEquals(new Integer(3),filtered.next());
- assertEquals(new Integer(6),filtered.next());
-
- assertEquals(new Integer(9),filtered.next());
- assertEquals(new Integer(12),filtered.next());
- assertEquals(new Integer(15),filtered.next());
- assertEquals(new Integer(15),filtered.previous());
- assertEquals(new Integer(12),filtered.previous());
- assertEquals(new Integer(9),filtered.previous());
-
+ assertEquals(new Integer(18), filtered.previous());
+ assertEquals(new Integer(15), filtered.previous());
+ assertEquals(new Integer(12), filtered.previous());
+ assertEquals(new Integer(9), filtered.previous());
+ assertEquals(new Integer(6), filtered.previous());
+ assertEquals(new Integer(3), filtered.previous());
+ assertEquals(new Integer(0), filtered.previous());
+
+ assertEquals(new Integer(0), filtered.next());
+ assertEquals(new Integer(0), filtered.previous());
+ assertEquals(new Integer(0), filtered.next());
+
+ assertEquals(new Integer(3), filtered.next());
+ assertEquals(new Integer(6), filtered.next());
+ assertEquals(new Integer(6), filtered.previous());
+ assertEquals(new Integer(3), filtered.previous());
+ assertEquals(new Integer(3), filtered.next());
+ assertEquals(new Integer(6), filtered.next());
+
+ assertEquals(new Integer(9), filtered.next());
+ assertEquals(new Integer(12), filtered.next());
+ assertEquals(new Integer(15), filtered.next());
+ assertEquals(new Integer(15), filtered.previous());
+ assertEquals(new Integer(12), filtered.previous());
+ assertEquals(new Integer(9), filtered.previous());
}
public void testTruePredicate() {
- FilterListIterator filtered = new FilterListIterator(list.listIterator(),truePred);
- walkLists(list,filtered);
+ FilterListIterator<Integer> filtered = new FilterListIterator<Integer>(list.listIterator(), truePred);
+ walkLists(list, filtered);
}
public void testFalsePredicate() {
- FilterListIterator filtered = new FilterListIterator(list.listIterator(),falsePred);
- walkLists(new ArrayList(),filtered);
+ FilterListIterator<Integer> filtered = new FilterListIterator<Integer>(list.listIterator(), falsePred);
+ walkLists(new ArrayList<Integer>(), filtered);
}
public void testEvens() {
- FilterListIterator filtered = new FilterListIterator(list.listIterator(),evenPred);
- walkLists(evens,filtered);
+ FilterListIterator<Integer> filtered = new FilterListIterator<Integer>(list.listIterator(), evenPred);
+ walkLists(evens, filtered);
}
public void testOdds() {
- FilterListIterator filtered = new FilterListIterator(list.listIterator(),oddPred);
- walkLists(odds,filtered);
+ FilterListIterator<Integer> filtered = new FilterListIterator<Integer>(list.listIterator(), oddPred);
+ walkLists(odds, filtered);
}
public void testThrees() {
- FilterListIterator filtered = new FilterListIterator(list.listIterator(),threePred);
- walkLists(threes,filtered);
+ FilterListIterator<Integer> filtered = new FilterListIterator<Integer>(list.listIterator(), threePred);
+ walkLists(threes, filtered);
}
public void testFours() {
- FilterListIterator filtered = new FilterListIterator(list.listIterator(),fourPred);
- walkLists(fours,filtered);
+ FilterListIterator<Integer> filtered = new FilterListIterator<Integer>(list.listIterator(), fourPred);
+ walkLists(fours, filtered);
}
public void testNestedSixes() {
- FilterListIterator filtered = new FilterListIterator(
- new FilterListIterator(list.listIterator(),threePred),
+ FilterListIterator<Integer> filtered = new FilterListIterator<Integer>(
+ new FilterListIterator<Integer>(list.listIterator(), threePred),
evenPred
);
- walkLists(sixes,filtered);
+ walkLists(sixes, filtered);
}
public void testNestedSixes2() {
- FilterListIterator filtered = new FilterListIterator(
- new FilterListIterator(list.listIterator(),evenPred),
+ FilterListIterator<Integer> filtered = new FilterListIterator<Integer>(
+ new FilterListIterator<Integer>(list.listIterator(), evenPred),
threePred
);
- walkLists(sixes,filtered);
+ walkLists(sixes, filtered);
}
public void testNestedSixes3() {
- FilterListIterator filtered = new FilterListIterator(
- new FilterListIterator(list.listIterator(),threePred),
+ FilterListIterator<Integer> filtered = new FilterListIterator<Integer>(
+ new FilterListIterator<Integer>(list.listIterator(), threePred),
evenPred
);
- walkLists(sixes,new FilterListIterator(filtered,truePred));
+ walkLists(sixes, new FilterListIterator<Integer>(filtered, truePred));
}
public void testNextChangesPrevious() {
{
- FilterListIterator filtered = new FilterListIterator(list.listIterator(),threePred);
- nextNextPrevious(threes.listIterator(),filtered);
+ FilterListIterator<Integer> filtered = new FilterListIterator<Integer>(list.listIterator(), threePred);
+ nextNextPrevious(threes.listIterator(), filtered);
}
{
- FilterListIterator filtered = new FilterListIterator(list.listIterator(),truePred);
- nextNextPrevious(list.listIterator(),filtered);
+ FilterListIterator<Integer> filtered = new FilterListIterator<Integer>(list.listIterator(), truePred);
+ nextNextPrevious(list.listIterator(), filtered);
}
}
public void testPreviousChangesNext() {
{
- FilterListIterator filtered = new FilterListIterator(list.listIterator(),threePred);
- ListIterator expected = threes.listIterator();
+ FilterListIterator<Integer> filtered = new FilterListIterator<Integer>(list.listIterator(), threePred);
+ ListIterator<Integer> expected = threes.listIterator();
walkForward(expected,filtered);
previousPreviousNext(expected,filtered);
}
{
- FilterListIterator filtered = new FilterListIterator(list.listIterator(),truePred);
- ListIterator expected = list.listIterator();
- walkForward(expected,filtered);
- previousPreviousNext(expected,filtered);
+ FilterListIterator<Integer> filtered = new FilterListIterator<Integer>(list.listIterator(), truePred);
+ ListIterator<Integer> expected = list.listIterator();
+ walkForward(expected, filtered);
+ previousPreviousNext(expected, filtered);
}
}
public void testFailingHasNextBug() {
- FilterListIterator filtered = new FilterListIterator(list.listIterator(),fourPred);
- ListIterator expected = fours.listIterator();
- while(expected.hasNext()) {
+ FilterListIterator<Integer> filtered = new FilterListIterator<Integer>(list.listIterator(), fourPred);
+ ListIterator<Integer> expected = fours.listIterator();
+ while (expected.hasNext()) {
expected.next();
filtered.next();
}
assertTrue(filtered.hasPrevious());
assertTrue(!filtered.hasNext());
- assertEquals(expected.previous(),filtered.previous());
+ assertEquals(expected.previous(), filtered.previous());
}
// Utilities
- private void walkForward(ListIterator expected, ListIterator testing) {
- while(expected.hasNext()) {
- assertEquals(expected.nextIndex(),testing.nextIndex());
- assertEquals(expected.previousIndex(),testing.previousIndex());
+ private void walkForward(ListIterator<?> expected, ListIterator<?> testing) {
+ while (expected.hasNext()) {
+ assertEquals(expected.nextIndex(), testing.nextIndex());
+ assertEquals(expected.previousIndex(), testing.previousIndex());
assertTrue(testing.hasNext());
- assertEquals(expected.next(),testing.next());
+ assertEquals(expected.next(), testing.next());
}
}
- private void walkBackward(ListIterator expected, ListIterator testing) {
- while(expected.hasPrevious()) {
- assertEquals(expected.nextIndex(),testing.nextIndex());
- assertEquals(expected.previousIndex(),testing.previousIndex());
+ private void walkBackward(ListIterator<?> expected, ListIterator<?> testing) {
+ while (expected.hasPrevious()) {
+ assertEquals(expected.nextIndex(), testing.nextIndex());
+ assertEquals(expected.previousIndex(), testing.previousIndex());
assertTrue(testing.hasPrevious());
- assertEquals(expected.previous(),testing.previous());
+ assertEquals(expected.previous(), testing.previous());
}
}
- private void nextNextPrevious(ListIterator expected, ListIterator testing) {
+ private void nextNextPrevious(ListIterator<?> expected, ListIterator<?> testing) {
// calls to next() should change the value returned by previous()
// even after previous() has been set by a call to hasPrevious()
- assertEquals(expected.next(),testing.next());
- assertEquals(expected.hasPrevious(),testing.hasPrevious());
+ assertEquals(expected.next(), testing.next());
+ assertEquals(expected.hasPrevious(), testing.hasPrevious());
Object expecteda = expected.next();
Object testinga = testing.next();
- assertEquals(expecteda,testinga);
+ assertEquals(expecteda, testinga);
Object expectedb = expected.previous();
Object testingb = testing.previous();
- assertEquals(expecteda,expectedb);
- assertEquals(testinga,testingb);
+ assertEquals(expecteda, expectedb);
+ assertEquals(testinga, testingb);
}
- private void previousPreviousNext(ListIterator expected, ListIterator testing) {
+ private void previousPreviousNext(ListIterator<?> expected, ListIterator<?> testing) {
// calls to previous() should change the value returned by next()
// even after next() has been set by a call to hasNext()
- assertEquals(expected.previous(),testing.previous());
- assertEquals(expected.hasNext(),testing.hasNext());
+ assertEquals(expected.previous(), testing.previous());
+ assertEquals(expected.hasNext(), testing.hasNext());
Object expecteda = expected.previous();
Object testinga = testing.previous();
- assertEquals(expecteda,testinga);
+ assertEquals(expecteda, testinga);
Object expectedb = expected.next();
Object testingb = testing.next();
- assertEquals(expecteda,testingb);
- assertEquals(expecteda,expectedb);
- assertEquals(testinga,testingb);
+ assertEquals(expecteda, testingb);
+ assertEquals(expecteda, expectedb);
+ assertEquals(testinga, testingb);
}
- private void walkLists(List list, ListIterator testing) {
- ListIterator expected = list.listIterator();
+ private <E> void walkLists(List<E> list, ListIterator<E> testing) {
+ ListIterator<E> expected = list.listIterator();
// walk all the way forward
walkForward(expected,testing);
@@ -348,74 +347,73 @@ public class TestFilterListIterator extends TestCase {
walkBackward(expected,testing);
// forward,back,forward
- while(expected.hasNext()) {
- assertEquals(expected.nextIndex(),testing.nextIndex());
- assertEquals(expected.previousIndex(),testing.previousIndex());
+ while (expected.hasNext()) {
+ assertEquals(expected.nextIndex(), testing.nextIndex());
+ assertEquals(expected.previousIndex(), testing.previousIndex());
assertTrue(testing.hasNext());
- assertEquals(expected.next(),testing.next());
+ assertEquals(expected.next(), testing.next());
assertTrue(testing.hasPrevious());
- assertEquals(expected.previous(),testing.previous());
+ assertEquals(expected.previous(), testing.previous());
assertTrue(testing.hasNext());
- assertEquals(expected.next(),testing.next());
+ assertEquals(expected.next(), testing.next());
}
-
// walk all the way back
- walkBackward(expected,testing);
+ walkBackward(expected, testing);
- for(int i=0;i<list.size();i++) {
+ for (int i = 0; i < list.size(); i++) {
// walk forward i
- for(int j=0;j<i;j++) {
- assertEquals(expected.nextIndex(),testing.nextIndex());
- assertEquals(expected.previousIndex(),testing.previousIndex());
+ for (int j = 0; j < i; j++) {
+ assertEquals(expected.nextIndex(), testing.nextIndex());
+ assertEquals(expected.previousIndex(), testing.previousIndex());
assertTrue(expected.hasNext()); // if this one fails we've got a logic error in the test
assertTrue(testing.hasNext());
- assertEquals(expected.next(),testing.next());
+ assertEquals(expected.next(), testing.next());
}
// walk back i/2
- for(int j=0;j<i/2;j++) {
- assertEquals(expected.nextIndex(),testing.nextIndex());
- assertEquals(expected.previousIndex(),testing.previousIndex());
+ for (int j = 0; j < i / 2; j++) {
+ assertEquals(expected.nextIndex(), testing.nextIndex());
+ assertEquals(expected.previousIndex(), testing.previousIndex());
assertTrue(expected.hasPrevious()); // if this one fails we've got a logic error in the test
assertTrue(testing.hasPrevious());
- assertEquals(expected.previous(),testing.previous());
+ assertEquals(expected.previous(), testing.previous());
}
// walk forward i/2
- for(int j=0;j<i/2;j++) {
- assertEquals(expected.nextIndex(),testing.nextIndex());
- assertEquals(expected.previousIndex(),testing.previousIndex());
+ for (int j = 0; j < i / 2; j++) {
+ assertEquals(expected.nextIndex(), testing.nextIndex());
+ assertEquals(expected.previousIndex(), testing.previousIndex());
assertTrue(expected.hasNext()); // if this one fails we've got a logic error in the test
assertTrue(testing.hasNext());
- assertEquals(expected.next(),testing.next());
+ assertEquals(expected.next(), testing.next());
}
// walk back i
- for(int j=0;j<i;j++) {
- assertEquals(expected.nextIndex(),testing.nextIndex());
- assertEquals(expected.previousIndex(),testing.previousIndex());
+ for (int j = 0; j < i; j++) {
+ assertEquals(expected.nextIndex(), testing.nextIndex());
+ assertEquals(expected.previousIndex(), testing.previousIndex());
assertTrue(expected.hasPrevious()); // if this one fails we've got a logic error in the test
assertTrue(testing.hasPrevious());
- assertEquals(expected.previous(),testing.previous());
+ assertEquals(expected.previous(), testing.previous());
}
}
// random walk
StringBuffer walkdescr = new StringBuffer(500);
- for(int i=0;i<500;i++) {
- if(random.nextBoolean()) {
+ for (int i = 0; i < 500; i++) {
+ if (random.nextBoolean()) {
// step forward
walkdescr.append("+");
- if(expected.hasNext()) {
- assertEquals(walkdescr.toString(),expected.next(),testing.next());
+ if (expected.hasNext()) {
+ assertEquals(walkdescr.toString(), expected.next(), testing.next());
}
} else {
// step backward
walkdescr.append("-");
- if(expected.hasPrevious()) {
- assertEquals(walkdescr.toString(),expected.previous(),testing.previous());
+ if (expected.hasPrevious()) {
+ assertEquals(walkdescr.toString(), expected.previous(), testing.previous());
}
}
- assertEquals(walkdescr.toString(),expected.nextIndex(),testing.nextIndex());
- assertEquals(walkdescr.toString(),expected.previousIndex(),testing.previousIndex());
+ assertEquals(walkdescr.toString(), expected.nextIndex(), testing.nextIndex());
+ assertEquals(walkdescr.toString(), expected.previousIndex(), testing.previousIndex());
}
}
http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/iterators/TestIteratorChain.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/iterators/TestIteratorChain.java b/src/test/org/apache/commons/collections/iterators/TestIteratorChain.java
index 9127ad0..eb3ed5e 100644
--- a/src/test/org/apache/commons/collections/iterators/TestIteratorChain.java
+++ b/src/test/org/apache/commons/collections/iterators/TestIteratorChain.java
@@ -36,15 +36,15 @@ import org.apache.commons.collections.Predicate;
* @author Mauricio S. Moura
* @author Morgan Delagrange
*/
-public class TestIteratorChain extends AbstractTestIterator {
+public class TestIteratorChain extends AbstractTestIterator<String> {
protected String[] testArray = {
"One", "Two", "Three", "Four", "Five", "Six"
};
- protected List list1 = null;
- protected List list2 = null;
- protected List list3 = null;
+ protected List<String> list1 = null;
+ protected List<String> list2 = null;
+ protected List<String> list3 = null;
public static Test suite() {
return new TestSuite(TestIteratorChain.class);
@@ -55,24 +55,24 @@ public class TestIteratorChain extends AbstractTestIterator {
}
public void setUp() {
- list1 = new ArrayList();
+ list1 = new ArrayList<String>();
list1.add("One");
list1.add("Two");
list1.add("Three");
- list2 = new ArrayList();
+ list2 = new ArrayList<String>();
list2.add("Four");
- list3 = new ArrayList();
+ list3 = new ArrayList<String>();
list3.add("Five");
list3.add("Six");
}
- public Iterator makeEmptyIterator() {
- ArrayList list = new ArrayList();
- return new IteratorChain(list.iterator());
+ public IteratorChain<String> makeEmptyIterator() {
+ ArrayList<String> list = new ArrayList<String>();
+ return new IteratorChain<String>(list.iterator());
}
- public Iterator makeFullIterator() {
- IteratorChain chain = new IteratorChain();
+ public IteratorChain<String> makeObject() {
+ IteratorChain<String> chain = new IteratorChain<String>();
chain.addIterator(list1.iterator());
chain.addIterator(list2.iterator());
@@ -81,18 +81,18 @@ public class TestIteratorChain extends AbstractTestIterator {
}
public void testIterator() {
- Iterator iter = (Iterator) makeFullIterator();
- for ( int i = 0; i < testArray.length; i++ ) {
+ Iterator<String> iter = makeObject();
+ for (int i = 0; i < testArray.length; i++) {
Object testValue = testArray[i];
Object iterValue = iter.next();
assertEquals( "Iteration value is correct", testValue, iterValue );
}
- assertTrue("Iterator should now be empty", ! iter.hasNext() );
+ assertTrue("Iterator should now be empty", !iter.hasNext());
try {
- Object testValue = iter.next();
+ iter.next();
} catch (Exception e) {
assertTrue("NoSuchElementException must be thrown",
e.getClass().equals((new NoSuchElementException()).getClass()));
@@ -101,38 +101,34 @@ public class TestIteratorChain extends AbstractTestIterator {
public void testRemoveFromFilteredIterator() {
- final Predicate myPredicate = new Predicate() {
- public boolean evaluate( Object object ) {
- Integer i = (Integer) object;
- if (i.compareTo(new Integer(4)) < 0)
- return true;
- return false;
+ final Predicate<Integer> myPredicate = new Predicate<Integer>() {
+ public boolean evaluate(Integer i) {
+ return i.compareTo(new Integer(4)) < 0;
}
};
- List list1 = new ArrayList();
- List list2 = new ArrayList();
+ List<Integer> list1 = new ArrayList<Integer>();
+ List<Integer> list2 = new ArrayList<Integer>();
list1.add(new Integer(1));
list1.add(new Integer(2));
list2.add(new Integer(3));
list2.add(new Integer(4)); // will be ignored by the predicate
- Iterator it1 = IteratorUtils.filteredIterator(list1.iterator(), myPredicate );
- Iterator it2 = IteratorUtils.filteredIterator(list2.iterator(), myPredicate );
+ Iterator<Integer> it1 = IteratorUtils.filteredIterator(list1.iterator(), myPredicate);
+ Iterator<Integer> it2 = IteratorUtils.filteredIterator(list2.iterator(), myPredicate);
- Iterator it = IteratorUtils.chainedIterator(it1, it2);
+ Iterator<Integer> it = IteratorUtils.chainedIterator(it1, it2);
while (it.hasNext()) {
it.next();
it.remove();
}
- assertEquals( 0, list1.size() );
- assertEquals( 1, list2.size() );
-
+ assertEquals(0, list1.size());
+ assertEquals(1, list2.size());
}
public void testRemove() {
- Iterator iter = (Iterator) makeFullIterator();
+ Iterator<String> iter = makeObject();
try {
iter.remove();
@@ -141,13 +137,13 @@ public class TestIteratorChain extends AbstractTestIterator {
}
- for ( int i = 0; i < testArray.length; i++ ) {
- Object testValue = testArray[i];
- Object iterValue = iter.next();
+ for (int i = 0; i < testArray.length; i++) {
+ String testValue = testArray[i];
+ String iterValue = iter.next();
- assertEquals( "Iteration value is correct", testValue, iterValue );
+ assertEquals("Iteration value is correct", testValue, iterValue);
- if (! iterValue.equals("Four")) {
+ if (!iterValue.equals("Four")) {
iter.remove();
}
}
@@ -158,12 +154,12 @@ public class TestIteratorChain extends AbstractTestIterator {
}
public void testFirstIteratorIsEmptyBug() {
- List empty = new ArrayList();
- List notEmpty = new ArrayList();
+ List<String> empty = new ArrayList<String>();
+ List<String> notEmpty = new ArrayList<String>();
notEmpty.add("A");
notEmpty.add("B");
notEmpty.add("C");
- IteratorChain chain = new IteratorChain();
+ IteratorChain<String> chain = new IteratorChain<String>();
chain.addIterator(empty.iterator());
chain.addIterator(notEmpty.iterator());
assertTrue("should have next",chain.hasNext());
@@ -176,7 +172,7 @@ public class TestIteratorChain extends AbstractTestIterator {
}
public void testEmptyChain() {
- IteratorChain chain = new IteratorChain();
+ IteratorChain<Object> chain = new IteratorChain<Object>();
assertEquals(false, chain.hasNext());
try {
chain.next();
http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/iterators/TestListIteratorWrapper.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/iterators/TestListIteratorWrapper.java b/src/test/org/apache/commons/collections/iterators/TestListIteratorWrapper.java
index 258f4e7..6f108b0 100644
--- a/src/test/org/apache/commons/collections/iterators/TestListIteratorWrapper.java
+++ b/src/test/org/apache/commons/collections/iterators/TestListIteratorWrapper.java
@@ -17,7 +17,6 @@
package org.apache.commons.collections.iterators;
import java.util.ArrayList;
-import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;
@@ -31,16 +30,16 @@ import org.apache.commons.collections.ResettableListIterator;
* a ListIterator correctly.
*
* @version $Revision$ $Date$
- *
+ *
* @author Morgan Delagrange
*/
-public class TestListIteratorWrapper extends AbstractTestIterator {
+public class TestListIteratorWrapper<E> extends AbstractTestIterator<E> {
protected String[] testArray = {
"One", "Two", "Three", "Four", "Five", "Six"
};
- protected List list1 = null;
+ protected List<E> list1 = null;
public static Test suite() {
return new TestSuite(TestListIteratorWrapper.class);
@@ -50,49 +49,48 @@ public class TestListIteratorWrapper extends AbstractTestIterator {
super(testName);
}
+ @SuppressWarnings("unchecked")
public void setUp() {
- list1 = new ArrayList();
- list1.add("One");
- list1.add("Two");
- list1.add("Three");
- list1.add("Four");
- list1.add("Five");
- list1.add("Six");
+ list1 = new ArrayList<E>();
+ list1.add((E) "One");
+ list1.add((E) "Two");
+ list1.add((E) "Three");
+ list1.add((E) "Four");
+ list1.add((E) "Five");
+ list1.add((E) "Six");
}
- public Iterator makeEmptyIterator() {
- ArrayList list = new ArrayList();
- return new ListIteratorWrapper(list.iterator());
+ public ResettableListIterator<E> makeEmptyIterator() {
+ ArrayList<E> list = new ArrayList<E>();
+ return new ListIteratorWrapper<E>(list.iterator());
}
- public Iterator makeFullIterator() {
- Iterator i = list1.iterator();
-
- return new ListIteratorWrapper(i);
+ public ResettableListIterator<E> makeObject() {
+ return new ListIteratorWrapper<E>(list1.iterator());
}
public void testIterator() {
- ListIterator iter = (ListIterator) makeFullIterator();
- for ( int i = 0; i < testArray.length; i++ ) {
- Object testValue = testArray[i];
+ ListIterator<E> iter = makeObject();
+ for (int i = 0; i < testArray.length; i++) {
+ Object testValue = testArray[i];
Object iterValue = iter.next();
- assertEquals( "Iteration value is correct", testValue, iterValue );
+ assertEquals("Iteration value is correct", testValue, iterValue);
}
- assertTrue("Iterator should now be empty", ! iter.hasNext() );
+ assertTrue("Iterator should now be empty", !iter.hasNext());
try {
iter.next();
} catch (Exception e) {
- assertTrue("NoSuchElementException must be thrown",
+ assertTrue("NoSuchElementException must be thrown",
e.getClass().equals((new NoSuchElementException()).getClass()));
}
// now, read it backwards
for (int i = testArray.length - 1; i > -1; --i) {
Object testValue = testArray[i];
- Object iterValue = iter.previous();
+ E iterValue = iter.previous();
assertEquals( "Iteration value is correct", testValue, iterValue );
}
@@ -100,22 +98,22 @@ public class TestListIteratorWrapper extends AbstractTestIterator {
try {
iter.previous();
} catch (Exception e) {
- assertTrue("NoSuchElementException must be thrown",
+ assertTrue("NoSuchElementException must be thrown",
e.getClass().equals((new NoSuchElementException()).getClass()));
}
// now, read it forwards again
- for ( int i = 0; i < testArray.length; i++ ) {
- Object testValue = testArray[i];
+ for (int i = 0; i < testArray.length; i++) {
+ Object testValue = testArray[i];
Object iterValue = iter.next();
- assertEquals( "Iteration value is correct", testValue, iterValue );
+ assertEquals("Iteration value is correct", testValue, iterValue);
}
}
public void testRemove() {
- Iterator iter = (Iterator) makeFullIterator();
+ ListIterator<E> iter = makeObject();
try {
iter.remove();
@@ -127,23 +125,23 @@ public class TestListIteratorWrapper extends AbstractTestIterator {
}
public void testReset() {
- ResettableListIterator iter = (ResettableListIterator) makeFullIterator();
- Object first = iter.next();
- Object second = iter.next();
-
+ ResettableListIterator<E> iter = makeObject();
+ E first = iter.next();
+ E second = iter.next();
+
iter.reset();
-
+
// after reset, there shouldn't be any previous elements
assertFalse("No previous elements after reset()", iter.hasPrevious());
// after reset, the results should be the same as before
assertEquals("First element should be the same", first, iter.next());
assertEquals("Second elment should be the same", second, iter.next());
-
+
// after passing the point, where we resetted, continuation should work as expected
for (int i = 2; i < testArray.length; i++) {
Object testValue = testArray[i];
- Object iterValue = iter.next();
+ E iterValue = iter.next();
assertEquals("Iteration value is correct", testValue, iterValue);
}
http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/iterators/TestLoopingIterator.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/iterators/TestLoopingIterator.java b/src/test/org/apache/commons/collections/iterators/TestLoopingIterator.java
index b3a7b9e..dfa572c 100644
--- a/src/test/org/apache/commons/collections/iterators/TestLoopingIterator.java
+++ b/src/test/org/apache/commons/collections/iterators/TestLoopingIterator.java
@@ -48,7 +48,7 @@ public class TestLoopingIterator extends TestCase {
*/
public void testConstructorEx() throws Exception {
try {
- new LoopingIterator(null);
+ new LoopingIterator<Object>(null);
fail();
} catch (NullPointerException ex) {
}
@@ -59,8 +59,8 @@ public class TestLoopingIterator extends TestCase {
* @throws Exception If something unexpected occurs.
*/
public void testLooping0() throws Exception {
- List list = new ArrayList();
- LoopingIterator loop = new LoopingIterator(list);
+ List<Object> list = new ArrayList<Object>();
+ LoopingIterator<Object> loop = new LoopingIterator<Object>(list);
assertTrue("hasNext should return false", loop.hasNext() == false);
try {
@@ -75,8 +75,8 @@ public class TestLoopingIterator extends TestCase {
* @throws Exception If something unexpected occurs.
*/
public void testLooping1() throws Exception {
- List list = new ArrayList(Arrays.asList(new String[] { "a" }));
- LoopingIterator loop = new LoopingIterator(list);
+ List<String> list = Arrays.asList(new String[] { "a" });
+ LoopingIterator<String> loop = new LoopingIterator<String>(list);
assertTrue("1st hasNext should return true", loop.hasNext());
assertEquals("a", loop.next());
@@ -94,8 +94,8 @@ public class TestLoopingIterator extends TestCase {
* @throws Exception If something unexpected occurs.
*/
public void testLooping2() throws Exception {
- List list = new ArrayList(Arrays.asList(new String[] { "a", "b" }));
- LoopingIterator loop = new LoopingIterator(list);
+ List<String> list = Arrays.asList(new String[] { "a", "b" });
+ LoopingIterator<String> loop = new LoopingIterator<String>(list);
assertTrue("1st hasNext should return true", loop.hasNext());
assertEquals("a", loop.next());
@@ -113,8 +113,8 @@ public class TestLoopingIterator extends TestCase {
* @throws Exception If something unexpected occurs.
*/
public void testLooping3() throws Exception {
- List list = new ArrayList(Arrays.asList(new String[] { "a", "b", "c" }));
- LoopingIterator loop = new LoopingIterator(list);
+ List<String> list = Arrays.asList(new String[] { "a", "b", "c" });
+ LoopingIterator<String> loop = new LoopingIterator<String>(list);
assertTrue("1st hasNext should return true", loop.hasNext());
assertEquals("a", loop.next());
@@ -135,8 +135,8 @@ public class TestLoopingIterator extends TestCase {
* @throws Exception If something unexpected occurs.
*/
public void testRemoving1() throws Exception {
- List list = new ArrayList(Arrays.asList(new String[] { "a", "b", "c" }));
- LoopingIterator loop = new LoopingIterator(list);
+ List<String> list = new ArrayList<String>(Arrays.asList(new String[] { "a", "b", "c" }));
+ LoopingIterator<String> loop = new LoopingIterator<String>(list);
assertEquals("list should have 3 elements.", 3, list.size());
assertTrue("1st hasNext should return true", loop.hasNext());
@@ -167,8 +167,8 @@ public class TestLoopingIterator extends TestCase {
* @throws Exception If something unexpected occurs.
*/
public void testReset() throws Exception {
- List list = new ArrayList(Arrays.asList(new String[] { "a", "b", "c" }));
- LoopingIterator loop = new LoopingIterator(list);
+ List<String> list = Arrays.asList(new String[] { "a", "b", "c" });
+ LoopingIterator<String> loop = new LoopingIterator<String>(list);
assertEquals("a", loop.next());
assertEquals("b", loop.next());
@@ -189,8 +189,8 @@ public class TestLoopingIterator extends TestCase {
* @throws Exception If something unexpected occurs.
*/
public void testSize() throws Exception {
- List list = new ArrayList(Arrays.asList(new String[] { "a", "b", "c" }));
- LoopingIterator loop = new LoopingIterator(list);
+ List<String> list = new ArrayList<String>(Arrays.asList(new String[] { "a", "b", "c" }));
+ LoopingIterator<String> loop = new LoopingIterator<String>(list);
assertEquals(3, loop.size());
loop.next();