You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by gg...@apache.org on 2018/02/22 20:30:46 UTC
commons-collections git commit: Sort members.
Repository: commons-collections
Updated Branches:
refs/heads/master 8accf274b -> 864fda437
Sort members.
Project: http://git-wip-us.apache.org/repos/asf/commons-collections/repo
Commit: http://git-wip-us.apache.org/repos/asf/commons-collections/commit/864fda43
Tree: http://git-wip-us.apache.org/repos/asf/commons-collections/tree/864fda43
Diff: http://git-wip-us.apache.org/repos/asf/commons-collections/diff/864fda43
Branch: refs/heads/master
Commit: 864fda4370a8d1bbd942400dd899653fd5d85244
Parents: 8accf27
Author: Gary Gregory <ga...@gmail.com>
Authored: Thu Feb 22 13:30:44 2018 -0700
Committer: Gary Gregory <ga...@gmail.com>
Committed: Thu Feb 22 13:30:44 2018 -0700
----------------------------------------------------------------------
.../commons/collections4/IteratorUtilsTest.java | 994 +++++++++----------
1 file changed, 497 insertions(+), 497 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/commons-collections/blob/864fda43/src/test/java/org/apache/commons/collections4/IteratorUtilsTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/collections4/IteratorUtilsTest.java b/src/test/java/org/apache/commons/collections4/IteratorUtilsTest.java
index a8eb7b4..989092a 100644
--- a/src/test/java/org/apache/commons/collections4/IteratorUtilsTest.java
+++ b/src/test/java/org/apache/commons/collections4/IteratorUtilsTest.java
@@ -73,9 +73,65 @@ public class IteratorUtilsTest {
*/
private List<Integer> collectionOdd = null;
+ private final Collection<Integer> emptyCollection = new ArrayList<>(1);
+
private Iterable<Integer> iterableA = null;
- private final Collection<Integer> emptyCollection = new ArrayList<>(1);
+ /**
+ * Creates a NodeList containing the specified nodes.
+ */
+ private NodeList createNodeList(final Node[] nodes) {
+ return new NodeList() {
+ @Override
+ public int getLength() {
+ return nodes.length;
+ }
+ @Override
+ public Node item(final int index) {
+ return nodes[index];
+ }
+ };
+ }
+
+ /**
+ * creates an array of four Node instances, mocked by EasyMock.
+ */
+ private Node[] createNodes() {
+ final Node node1 = createMock(Node.class);
+ final Node node2 = createMock(Node.class);
+ final Node node3 = createMock(Node.class);
+ final Node node4 = createMock(Node.class);
+ replay(node1);
+ replay(node2);
+ replay(node3);
+ replay(node4);
+
+ return new Node[]{node1, node2, node3, node4};
+}
+
+ /**
+ * Gets an immutable Iterator operating on the elements ["a", "b", "c", "d"].
+ */
+ private Iterator<String> getImmutableIterator() {
+ final List<String> list = new ArrayList<>();
+ list.add("a");
+ list.add("b");
+ list.add("c");
+ list.add("d");
+ return IteratorUtils.unmodifiableIterator(list.iterator());
+ }
+
+ /**
+ * Gets an immutable ListIterator operating on the elements ["a", "b", "c", "d"].
+ */
+ private ListIterator<String> getImmutableListIterator() {
+ final List<String> list = new ArrayList<>();
+ list.add("a");
+ list.add("b");
+ list.add("c");
+ list.add("d");
+ return IteratorUtils.unmodifiableListIterator(list.listIterator());
+ }
@Before
public void setUp() {
@@ -98,125 +154,6 @@ public class IteratorUtilsTest {
}
@Test
- public void testAsIterable() {
- final List<Integer> list = new ArrayList<>();
- list.add(Integer.valueOf(0));
- list.add(Integer.valueOf(1));
- list.add(Integer.valueOf(2));
- final Iterator<Integer> iterator = list.iterator();
-
- final Iterable<Integer> iterable = IteratorUtils.asIterable(iterator);
- int expected = 0;
- for(final Integer actual : iterable) {
- assertEquals(expected, actual.intValue());
- ++expected;
- }
- // insure iteration occurred
- assertTrue(expected > 0);
-
- // single use iterator
- assertFalse("should not be able to iterate twice", IteratorUtils.asIterable(iterator).iterator().hasNext());
- }
-
- @Test
- public void testAsIterableNull() {
- try {
- IteratorUtils.asIterable(null);
- fail("Expecting NullPointerException");
- } catch (final NullPointerException ex) {
- // success
- }
- }
-
- @Test
- public void testAsMultipleIterable() {
- final List<Integer> list = new ArrayList<>();
- list.add(Integer.valueOf(0));
- list.add(Integer.valueOf(1));
- list.add(Integer.valueOf(2));
- final Iterator<Integer> iterator = list.iterator();
-
- final Iterable<Integer> iterable = IteratorUtils.asMultipleUseIterable(iterator);
- int expected = 0;
- for(final Integer actual : iterable) {
- assertEquals(expected, actual.intValue());
- ++expected;
- }
- // insure iteration occurred
- assertTrue(expected > 0);
-
- // multiple use iterator
- expected = 0;
- for(final Integer actual : iterable) {
- assertEquals(expected, actual.intValue());
- ++expected;
- }
- // insure iteration occurred
- assertTrue(expected > 0);
- }
-
- @Test
- public void testAsMultipleIterableNull() {
- try {
- IteratorUtils.asMultipleUseIterable(null);
- fail("Expecting NullPointerException");
- } catch (final NullPointerException ex) {
- // success
- }
- }
-
- @Test
- public void testToList() {
- final List<Object> list = new ArrayList<>();
- list.add(Integer.valueOf(1));
- list.add("Two");
- list.add(null);
- final List<Object> result = IteratorUtils.toList(list.iterator());
- assertEquals(list, result);
- }
-
- @Test
- public void testToArray() {
- final List<Object> list = new ArrayList<>();
- list.add(Integer.valueOf(1));
- list.add("Two");
- list.add(null);
- final Object[] result = IteratorUtils.toArray(list.iterator());
- assertEquals(list, Arrays.asList(result));
-
- try {
- IteratorUtils.toArray(null);
- fail("Expecting NullPointerException");
- } catch (final NullPointerException ex) {
- // success
- }
- }
-
- @Test
- public void testToArray2() {
- final List<String> list = new ArrayList<>();
- list.add("One");
- list.add("Two");
- list.add(null);
- final String[] result = IteratorUtils.toArray(list.iterator(), String.class);
- assertEquals(list, Arrays.asList(result));
-
- try {
- IteratorUtils.toArray(list.iterator(), null);
- fail("Expecting NullPointerException");
- } catch (final NullPointerException ex) {
- // success
- }
-
- try {
- IteratorUtils.toArray(null, String.class);
- fail("Expecting NullPointerException");
- } catch (final NullPointerException ex) {
- // success
- }
- }
-
- @Test
public void testArrayIterator() {
final Object[] objArray = {"a", "b", "c"};
ResettableIterator<Object> iterator = IteratorUtils.arrayIterator(objArray);
@@ -500,71 +437,166 @@ public class IteratorUtilsTest {
}
}
+ @Test
+ public void testAsIterable() {
+ final List<Integer> list = new ArrayList<>();
+ list.add(Integer.valueOf(0));
+ list.add(Integer.valueOf(1));
+ list.add(Integer.valueOf(2));
+ final Iterator<Integer> iterator = list.iterator();
- /**
- * Gets an immutable Iterator operating on the elements ["a", "b", "c", "d"].
- */
- private Iterator<String> getImmutableIterator() {
- final List<String> list = new ArrayList<>();
- list.add("a");
- list.add("b");
- list.add("c");
- list.add("d");
- return IteratorUtils.unmodifiableIterator(list.iterator());
- }
+ final Iterable<Integer> iterable = IteratorUtils.asIterable(iterator);
+ int expected = 0;
+ for(final Integer actual : iterable) {
+ assertEquals(expected, actual.intValue());
+ ++expected;
+ }
+ // insure iteration occurred
+ assertTrue(expected > 0);
- /**
- * Gets an immutable ListIterator operating on the elements ["a", "b", "c", "d"].
- */
- private ListIterator<String> getImmutableListIterator() {
- final List<String> list = new ArrayList<>();
- list.add("a");
- list.add("b");
- list.add("c");
- list.add("d");
- return IteratorUtils.unmodifiableListIterator(list.listIterator());
+ // single use iterator
+ assertFalse("should not be able to iterate twice", IteratorUtils.asIterable(iterator).iterator().hasNext());
}
- //-----------------------------------------------------------------------
- /**
- * Test empty iterator
- */
@Test
- public void testEmptyIterator() {
- assertSame(EmptyIterator.INSTANCE, IteratorUtils.EMPTY_ITERATOR);
- assertSame(EmptyIterator.RESETTABLE_INSTANCE, IteratorUtils.EMPTY_ITERATOR);
- assertEquals(true, IteratorUtils.EMPTY_ITERATOR instanceof Iterator);
- assertEquals(true, IteratorUtils.EMPTY_ITERATOR instanceof ResettableIterator);
- assertEquals(false, IteratorUtils.EMPTY_ITERATOR instanceof OrderedIterator);
- assertEquals(false, IteratorUtils.EMPTY_ITERATOR instanceof ListIterator);
- assertEquals(false, IteratorUtils.EMPTY_ITERATOR instanceof MapIterator);
- assertEquals(false, IteratorUtils.EMPTY_ITERATOR.hasNext());
- IteratorUtils.EMPTY_ITERATOR.reset();
- assertSame(IteratorUtils.EMPTY_ITERATOR, IteratorUtils.EMPTY_ITERATOR);
- assertSame(IteratorUtils.EMPTY_ITERATOR, IteratorUtils.emptyIterator());
- try {
- IteratorUtils.EMPTY_ITERATOR.next();
- fail();
- } catch (final NoSuchElementException ex) {}
+ public void testAsIterableNull() {
try {
- IteratorUtils.EMPTY_ITERATOR.remove();
- fail();
- } catch (final IllegalStateException ex) {}
+ IteratorUtils.asIterable(null);
+ fail("Expecting NullPointerException");
+ } catch (final NullPointerException ex) {
+ // success
+ }
}
- //-----------------------------------------------------------------------
- /**
- * Test empty list iterator
- */
@Test
- public void testEmptyListIterator() {
- assertSame(EmptyListIterator.INSTANCE, IteratorUtils.EMPTY_LIST_ITERATOR);
- assertSame(EmptyListIterator.RESETTABLE_INSTANCE, IteratorUtils.EMPTY_LIST_ITERATOR);
- assertEquals(true, IteratorUtils.EMPTY_LIST_ITERATOR instanceof Iterator);
- assertEquals(true, IteratorUtils.EMPTY_LIST_ITERATOR instanceof ListIterator);
- assertEquals(true, IteratorUtils.EMPTY_LIST_ITERATOR instanceof ResettableIterator);
- assertEquals(true, IteratorUtils.EMPTY_LIST_ITERATOR instanceof ResettableListIterator);
- assertEquals(false, IteratorUtils.EMPTY_LIST_ITERATOR instanceof MapIterator);
+ public void testAsMultipleIterable() {
+ final List<Integer> list = new ArrayList<>();
+ list.add(Integer.valueOf(0));
+ list.add(Integer.valueOf(1));
+ list.add(Integer.valueOf(2));
+ final Iterator<Integer> iterator = list.iterator();
+
+ final Iterable<Integer> iterable = IteratorUtils.asMultipleUseIterable(iterator);
+ int expected = 0;
+ for(final Integer actual : iterable) {
+ assertEquals(expected, actual.intValue());
+ ++expected;
+ }
+ // insure iteration occurred
+ assertTrue(expected > 0);
+
+ // multiple use iterator
+ expected = 0;
+ for(final Integer actual : iterable) {
+ assertEquals(expected, actual.intValue());
+ ++expected;
+ }
+ // insure iteration occurred
+ assertTrue(expected > 0);
+ }
+
+
+ @Test
+ public void testAsMultipleIterableNull() {
+ try {
+ IteratorUtils.asMultipleUseIterable(null);
+ fail("Expecting NullPointerException");
+ } catch (final NullPointerException ex) {
+ // success
+ }
+ }
+
+ /**
+ * Tests methods collatedIterator(...)
+ */
+ @Test
+ public void testCollatedIterator() {
+ try {
+ IteratorUtils.collatedIterator(null, collectionOdd.iterator(), null);
+ fail("expecting NullPointerException");
+ } catch (final NullPointerException npe) {
+ // expected
+ }
+
+ try {
+ IteratorUtils.collatedIterator(null, null, collectionEven.iterator());
+ fail("expecting NullPointerException");
+ } catch (final NullPointerException npe) {
+ // expected
+ }
+
+ // natural ordering
+ Iterator<Integer> it =
+ IteratorUtils.collatedIterator(null, collectionOdd.iterator(), collectionEven.iterator());
+
+ List<Integer> result = IteratorUtils.toList(it);
+ assertEquals(12, result.size());
+
+ final List<Integer> combinedList = new ArrayList<>();
+ combinedList.addAll(collectionOdd);
+ combinedList.addAll(collectionEven);
+ Collections.sort(combinedList);
+
+ assertEquals(combinedList, result);
+
+ it = IteratorUtils.collatedIterator(null, collectionOdd.iterator(), emptyCollection.iterator());
+ result = IteratorUtils.toList(it);
+ assertEquals(collectionOdd, result);
+
+ final Comparator<Integer> reverseComparator =
+ ComparatorUtils.reversedComparator(ComparatorUtils.<Integer>naturalComparator());
+
+ Collections.reverse(collectionOdd);
+ Collections.reverse(collectionEven);
+ Collections.reverse(combinedList);
+
+ it = IteratorUtils.collatedIterator(reverseComparator,
+ collectionOdd.iterator(),
+ collectionEven.iterator());
+ result = IteratorUtils.toList(it);
+ assertEquals(combinedList, result);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Test empty iterator
+ */
+ @Test
+ public void testEmptyIterator() {
+ assertSame(EmptyIterator.INSTANCE, IteratorUtils.EMPTY_ITERATOR);
+ assertSame(EmptyIterator.RESETTABLE_INSTANCE, IteratorUtils.EMPTY_ITERATOR);
+ assertEquals(true, IteratorUtils.EMPTY_ITERATOR instanceof Iterator);
+ assertEquals(true, IteratorUtils.EMPTY_ITERATOR instanceof ResettableIterator);
+ assertEquals(false, IteratorUtils.EMPTY_ITERATOR instanceof OrderedIterator);
+ assertEquals(false, IteratorUtils.EMPTY_ITERATOR instanceof ListIterator);
+ assertEquals(false, IteratorUtils.EMPTY_ITERATOR instanceof MapIterator);
+ assertEquals(false, IteratorUtils.EMPTY_ITERATOR.hasNext());
+ IteratorUtils.EMPTY_ITERATOR.reset();
+ assertSame(IteratorUtils.EMPTY_ITERATOR, IteratorUtils.EMPTY_ITERATOR);
+ assertSame(IteratorUtils.EMPTY_ITERATOR, IteratorUtils.emptyIterator());
+ try {
+ IteratorUtils.EMPTY_ITERATOR.next();
+ fail();
+ } catch (final NoSuchElementException ex) {}
+ try {
+ IteratorUtils.EMPTY_ITERATOR.remove();
+ fail();
+ } catch (final IllegalStateException ex) {}
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Test empty list iterator
+ */
+ @Test
+ public void testEmptyListIterator() {
+ assertSame(EmptyListIterator.INSTANCE, IteratorUtils.EMPTY_LIST_ITERATOR);
+ assertSame(EmptyListIterator.RESETTABLE_INSTANCE, IteratorUtils.EMPTY_LIST_ITERATOR);
+ assertEquals(true, IteratorUtils.EMPTY_LIST_ITERATOR instanceof Iterator);
+ assertEquals(true, IteratorUtils.EMPTY_LIST_ITERATOR instanceof ListIterator);
+ assertEquals(true, IteratorUtils.EMPTY_LIST_ITERATOR instanceof ResettableIterator);
+ assertEquals(true, IteratorUtils.EMPTY_LIST_ITERATOR instanceof ResettableListIterator);
+ assertEquals(false, IteratorUtils.EMPTY_LIST_ITERATOR instanceof MapIterator);
assertEquals(false, IteratorUtils.EMPTY_LIST_ITERATOR.hasNext());
assertEquals(0, IteratorUtils.EMPTY_LIST_ITERATOR.nextIndex());
assertEquals(-1, IteratorUtils.EMPTY_LIST_ITERATOR.previousIndex());
@@ -709,83 +741,264 @@ public class IteratorUtilsTest {
} catch (final IllegalStateException ex) {}
}
- //-----------------------------------------------------------------------
- /**
- * Test next() and hasNext() for an immutable Iterator.
- */
@Test
- public void testUnmodifiableIteratorIteration() {
- final Iterator<String> iterator = getImmutableIterator();
-
- assertTrue(iterator.hasNext());
-
- assertEquals("a", iterator.next());
-
- assertTrue(iterator.hasNext());
+ public void testFind() {
+ Predicate<Number> testPredicate = equalPredicate((Number) 4);
+ Integer test = IteratorUtils.find(iterableA.iterator(), testPredicate);
+ assertTrue(test.equals(4));
+ testPredicate = equalPredicate((Number) 45);
+ test = IteratorUtils.find(iterableA.iterator(), testPredicate);
+ assertTrue(test == null);
+ assertNull(IteratorUtils.find(null,testPredicate));
+ try {
+ assertNull(IteratorUtils.find(iterableA.iterator(), null));
+ fail("expecting NullPointerException");
+ } catch (final NullPointerException npe) {
+ // expected
+ }
+ }
- assertEquals("b", iterator.next());
+ @Test
+ public void testFirstFromIterator() throws Exception {
+ // Iterator, entry exists
+ Iterator<Integer> iterator = iterableA.iterator();
+ assertEquals(1, (int) IteratorUtils.first(iterator));
+ }
- assertTrue(iterator.hasNext());
+ // -----------------------------------------------------------------------
+ @Test
+ public void testForEach() {
+ final List<Integer> listA = new ArrayList<>();
+ listA.add(1);
- assertEquals("c", iterator.next());
+ final List<Integer> listB = new ArrayList<>();
+ listB.add(2);
- assertTrue(iterator.hasNext());
+ final Closure<List<Integer>> testClosure = ClosureUtils.invokerClosure("clear");
+ final Collection<List<Integer>> col = new ArrayList<>();
+ col.add(listA);
+ col.add(listB);
+ IteratorUtils.forEach(col.iterator(), testClosure);
+ assertTrue(listA.isEmpty() && listB.isEmpty());
+ try {
+ IteratorUtils.forEach(col.iterator(), null);
+ fail("expecting NullPointerException");
+ } catch (final NullPointerException npe) {
+ // expected
+ }
- assertEquals("d", iterator.next());
+ IteratorUtils.forEach(null, testClosure);
- assertTrue(!iterator.hasNext());
+ // null should be OK
+ col.add(null);
+ IteratorUtils.forEach(col.iterator(), testClosure);
}
- /**
- * Test next(), hasNext(), previous() and hasPrevious() for an immutable
- * ListIterator.
- */
@Test
- public void testUnmodifiableListIteratorIteration() {
- final ListIterator<String> listIterator = getImmutableListIterator();
-
- assertTrue(!listIterator.hasPrevious());
- assertTrue(listIterator.hasNext());
+ public void testForEachButLast() {
+ final List<Integer> listA = new ArrayList<>();
+ listA.add(1);
- assertEquals("a", listIterator.next());
+ final List<Integer> listB = new ArrayList<>();
+ listB.add(2);
- assertTrue(listIterator.hasPrevious());
- assertTrue(listIterator.hasNext());
+ final Closure<List<Integer>> testClosure = ClosureUtils.invokerClosure("clear");
+ final Collection<List<Integer>> col = new ArrayList<>();
+ col.add(listA);
+ col.add(listB);
+ List<Integer> last = IteratorUtils.forEachButLast(col.iterator(), testClosure);
+ assertTrue(listA.isEmpty() && !listB.isEmpty());
+ assertSame(listB, last);
- assertEquals("b", listIterator.next());
+ try {
+ IteratorUtils.forEachButLast(col.iterator(), null);
+ fail("expecting NullPointerException");
+ } catch (final NullPointerException npe) {
+ // expected
+ }
- assertTrue(listIterator.hasPrevious());
- assertTrue(listIterator.hasNext());
+ IteratorUtils.forEachButLast(null, testClosure);
- assertEquals("c", listIterator.next());
+ // null should be OK
+ col.add(null);
+ col.add(null);
+ last = IteratorUtils.forEachButLast(col.iterator(), testClosure);
+ assertNull(last);
+ }
- assertTrue(listIterator.hasPrevious());
- assertTrue(listIterator.hasNext());
+ @Test
+ public void testGetAtIndexFromIterator() throws Exception {
+ // Iterator, entry exists
+ Iterator<Integer> iterator = iterableA.iterator();
+ assertEquals(1, (int) IteratorUtils.get(iterator, 0));
+ iterator = iterableA.iterator();
+ assertEquals(2, (int) IteratorUtils.get(iterator, 1));
- assertEquals("d", listIterator.next());
+ // Iterator, non-existent entry
+ try {
+ IteratorUtils.get(iterator, 10);
+ fail("Expecting IndexOutOfBoundsException.");
+ } catch (final IndexOutOfBoundsException e) {
+ // expected
+ }
+ assertTrue(!iterator.hasNext());
+ }
+ @Test
+ public void testGetIterator() {
+ final Object[] objArray = {"a", "b", "c"};
+ final Map<String, String> inMap = new HashMap<>();
+ final Node[] nodes = createNodes();
+ final NodeList nodeList = createNodeList(nodes);
- assertTrue(listIterator.hasPrevious());
- assertTrue(!listIterator.hasNext());
+ assertTrue("returns empty iterator when null passed", IteratorUtils.getIterator(null) instanceof EmptyIterator);
+ assertTrue("returns Iterator when Iterator directly ", IteratorUtils.getIterator(iterableA.iterator()) instanceof Iterator);
+ assertTrue("returns Iterator when iterable passed", IteratorUtils.getIterator(iterableA) instanceof Iterator);
+ assertTrue("returns ObjectArrayIterator when Object array passed", IteratorUtils.getIterator(objArray) instanceof ObjectArrayIterator);
+ assertTrue("returns Iterator when Map passed", IteratorUtils.getIterator(inMap) instanceof Iterator);
+ assertTrue("returns NodeListIterator when nodeList passed", IteratorUtils.getIterator(nodeList) instanceof NodeListIterator);
+ assertTrue("returns EnumerationIterator when Enumeration passed", IteratorUtils.getIterator(new Vector().elements()) instanceof EnumerationIterator);
- assertEquals("d", listIterator.previous());
+ }
- assertTrue(listIterator.hasPrevious());
- assertTrue(listIterator.hasNext());
+ @Test
+ public void testIndexOf() {
+ Predicate<Number> testPredicate = equalPredicate((Number) 4);
+ int index = IteratorUtils.indexOf(iterableA.iterator(), testPredicate);
+ assertEquals(6, index);
+ testPredicate = equalPredicate((Number) 45);
+ index = IteratorUtils.indexOf(iterableA.iterator(), testPredicate);
+ assertEquals(-1, index);
+ assertEquals(-1, IteratorUtils.indexOf(null, testPredicate));
+ try {
+ IteratorUtils.indexOf(iterableA.iterator(), null);
+ fail("expecting NullPointerException");
+ } catch (final NullPointerException npe) {
+ // expected
+ }
+ }
- assertEquals("c", listIterator.previous());
+ /**
+ * Tests method nodeListIterator(Node)
+ */
+ @Test
+ public void testNodeIterator() {
+ final Node[] nodes = createNodes();
+ final NodeList nodeList = createNodeList(nodes);
+ final Node parentNode = createMock(Node.class);
+ expect(parentNode.getChildNodes()).andStubReturn(nodeList);
+ replay(parentNode);
- assertTrue(listIterator.hasPrevious());
- assertTrue(listIterator.hasNext());
+ final Iterator<Node> iterator = IteratorUtils.nodeListIterator(parentNode);
+ int expectedNodeIndex = 0;
+ for (final Node actual : IteratorUtils.asIterable(iterator)) {
+ assertEquals(nodes[expectedNodeIndex], actual);
+ ++expectedNodeIndex;
+ }
- assertEquals("b", listIterator.previous());
+ // insure iteration occurred
+ assertTrue(expectedNodeIndex > 0);
- assertTrue(listIterator.hasPrevious());
- assertTrue(listIterator.hasNext());
+ // single use iterator
+ assertFalse("should not be able to iterate twice", IteratorUtils.asIterable(iterator).iterator().hasNext());
+ }
- assertEquals("a", listIterator.previous());
+ /**
+ * Tests method nodeListIterator(NodeList)
+ */
+ @Test
+ public void testNodeListIterator() {
+ final Node[] nodes = createNodes();
+ final NodeList nodeList = createNodeList(nodes);
- assertTrue(!listIterator.hasPrevious());
- assertTrue(listIterator.hasNext());
+ final Iterator<Node> iterator = IteratorUtils.nodeListIterator(nodeList);
+ int expectedNodeIndex = 0;
+ for (final Node actual : IteratorUtils.asIterable(iterator)) {
+ assertEquals(nodes[expectedNodeIndex], actual);
+ ++expectedNodeIndex;
+ }
+
+ // insure iteration occurred
+ assertTrue(expectedNodeIndex > 0);
+
+ // single use iterator
+ assertFalse("should not be able to iterate twice", IteratorUtils.asIterable(iterator).iterator().hasNext());
+ }
+
+ @Test
+ public void testToArray() {
+ final List<Object> list = new ArrayList<>();
+ list.add(Integer.valueOf(1));
+ list.add("Two");
+ list.add(null);
+ final Object[] result = IteratorUtils.toArray(list.iterator());
+ assertEquals(list, Arrays.asList(result));
+
+ try {
+ IteratorUtils.toArray(null);
+ fail("Expecting NullPointerException");
+ } catch (final NullPointerException ex) {
+ // success
+ }
+ }
+
+ @Test
+ public void testToArray2() {
+ final List<String> list = new ArrayList<>();
+ list.add("One");
+ list.add("Two");
+ list.add(null);
+ final String[] result = IteratorUtils.toArray(list.iterator(), String.class);
+ assertEquals(list, Arrays.asList(result));
+
+ try {
+ IteratorUtils.toArray(list.iterator(), null);
+ fail("Expecting NullPointerException");
+ } catch (final NullPointerException ex) {
+ // success
+ }
+
+ try {
+ IteratorUtils.toArray(null, String.class);
+ fail("Expecting NullPointerException");
+ } catch (final NullPointerException ex) {
+ // success
+ }
+ }
+
+ @Test
+ public void testToList() {
+ final List<Object> list = new ArrayList<>();
+ list.add(Integer.valueOf(1));
+ list.add("Two");
+ list.add(null);
+ final List<Object> result = IteratorUtils.toList(list.iterator());
+ assertEquals(list, result);
+ }
+
+ @Test
+ public void testToListIterator() {
+ final List<Integer> list = new ArrayList<>();
+ list.add(Integer.valueOf(0));
+ list.add(Integer.valueOf(1));
+ list.add(Integer.valueOf(2));
+ final Iterator<Integer> iterator = list.iterator();
+
+ final ListIterator<Integer> liItr = IteratorUtils.toListIterator(iterator);
+ int expected = 0;
+ while(liItr.hasNext()){
+ assertEquals(expected, liItr.next().intValue());
+ ++expected;
+ }
+ }
+
+ @Test
+ public void testToListIteratorNull() {
+ try {
+ IteratorUtils.toListIterator(null);
+ fail("Expecting NullPointerException");
+ } catch (final NullPointerException ex) {
+ // success
+ }
}
/**
@@ -815,6 +1028,33 @@ public class IteratorUtilsTest {
}
+ //-----------------------------------------------------------------------
+ /**
+ * Test next() and hasNext() for an immutable Iterator.
+ */
+ @Test
+ public void testUnmodifiableIteratorIteration() {
+ final Iterator<String> iterator = getImmutableIterator();
+
+ assertTrue(iterator.hasNext());
+
+ assertEquals("a", iterator.next());
+
+ assertTrue(iterator.hasNext());
+
+ assertEquals("b", iterator.next());
+
+ assertTrue(iterator.hasNext());
+
+ assertEquals("c", iterator.next());
+
+ assertTrue(iterator.hasNext());
+
+ assertEquals("d", iterator.next());
+
+ assertTrue(!iterator.hasNext());
+ }
+
/**
* Test remove() for an immutable ListIterator.
*/
@@ -874,295 +1114,55 @@ public class IteratorUtilsTest {
}
/**
- * Tests method nodeListIterator(NodeList)
- */
- @Test
- public void testNodeListIterator() {
- final Node[] nodes = createNodes();
- final NodeList nodeList = createNodeList(nodes);
-
- final Iterator<Node> iterator = IteratorUtils.nodeListIterator(nodeList);
- int expectedNodeIndex = 0;
- for (final Node actual : IteratorUtils.asIterable(iterator)) {
- assertEquals(nodes[expectedNodeIndex], actual);
- ++expectedNodeIndex;
- }
-
- // insure iteration occurred
- assertTrue(expectedNodeIndex > 0);
-
- // single use iterator
- assertFalse("should not be able to iterate twice", IteratorUtils.asIterable(iterator).iterator().hasNext());
- }
- /**
- * Tests method nodeListIterator(Node)
- */
- @Test
- public void testNodeIterator() {
- final Node[] nodes = createNodes();
- final NodeList nodeList = createNodeList(nodes);
- final Node parentNode = createMock(Node.class);
- expect(parentNode.getChildNodes()).andStubReturn(nodeList);
- replay(parentNode);
-
- final Iterator<Node> iterator = IteratorUtils.nodeListIterator(parentNode);
- int expectedNodeIndex = 0;
- for (final Node actual : IteratorUtils.asIterable(iterator)) {
- assertEquals(nodes[expectedNodeIndex], actual);
- ++expectedNodeIndex;
- }
-
- // insure iteration occurred
- assertTrue(expectedNodeIndex > 0);
-
- // single use iterator
- assertFalse("should not be able to iterate twice", IteratorUtils.asIterable(iterator).iterator().hasNext());
- }
-
- /**
- * creates an array of four Node instances, mocked by EasyMock.
- */
- private Node[] createNodes() {
- final Node node1 = createMock(Node.class);
- final Node node2 = createMock(Node.class);
- final Node node3 = createMock(Node.class);
- final Node node4 = createMock(Node.class);
- replay(node1);
- replay(node2);
- replay(node3);
- replay(node4);
-
- return new Node[]{node1, node2, node3, node4};
-}
-
- /**
- * Creates a NodeList containing the specified nodes.
- */
- private NodeList createNodeList(final Node[] nodes) {
- return new NodeList() {
- @Override
- public Node item(final int index) {
- return nodes[index];
- }
- @Override
- public int getLength() {
- return nodes.length;
- }
- };
- }
-
- /**
- * Tests methods collatedIterator(...)
+ * Test next(), hasNext(), previous() and hasPrevious() for an immutable
+ * ListIterator.
*/
@Test
- public void testCollatedIterator() {
- try {
- IteratorUtils.collatedIterator(null, collectionOdd.iterator(), null);
- fail("expecting NullPointerException");
- } catch (final NullPointerException npe) {
- // expected
- }
-
- try {
- IteratorUtils.collatedIterator(null, null, collectionEven.iterator());
- fail("expecting NullPointerException");
- } catch (final NullPointerException npe) {
- // expected
- }
-
- // natural ordering
- Iterator<Integer> it =
- IteratorUtils.collatedIterator(null, collectionOdd.iterator(), collectionEven.iterator());
-
- List<Integer> result = IteratorUtils.toList(it);
- assertEquals(12, result.size());
-
- final List<Integer> combinedList = new ArrayList<>();
- combinedList.addAll(collectionOdd);
- combinedList.addAll(collectionEven);
- Collections.sort(combinedList);
-
- assertEquals(combinedList, result);
-
- it = IteratorUtils.collatedIterator(null, collectionOdd.iterator(), emptyCollection.iterator());
- result = IteratorUtils.toList(it);
- assertEquals(collectionOdd, result);
-
- final Comparator<Integer> reverseComparator =
- ComparatorUtils.reversedComparator(ComparatorUtils.<Integer>naturalComparator());
-
- Collections.reverse(collectionOdd);
- Collections.reverse(collectionEven);
- Collections.reverse(combinedList);
-
- it = IteratorUtils.collatedIterator(reverseComparator,
- collectionOdd.iterator(),
- collectionEven.iterator());
- result = IteratorUtils.toList(it);
- assertEquals(combinedList, result);
- }
-
- // -----------------------------------------------------------------------
- @Test
- public void testForEach() {
- final List<Integer> listA = new ArrayList<>();
- listA.add(1);
-
- final List<Integer> listB = new ArrayList<>();
- listB.add(2);
-
- final Closure<List<Integer>> testClosure = ClosureUtils.invokerClosure("clear");
- final Collection<List<Integer>> col = new ArrayList<>();
- col.add(listA);
- col.add(listB);
- IteratorUtils.forEach(col.iterator(), testClosure);
- assertTrue(listA.isEmpty() && listB.isEmpty());
- try {
- IteratorUtils.forEach(col.iterator(), null);
- fail("expecting NullPointerException");
- } catch (final NullPointerException npe) {
- // expected
- }
-
- IteratorUtils.forEach(null, testClosure);
-
- // null should be OK
- col.add(null);
- IteratorUtils.forEach(col.iterator(), testClosure);
- }
+ public void testUnmodifiableListIteratorIteration() {
+ final ListIterator<String> listIterator = getImmutableListIterator();
- @Test
- public void testForEachButLast() {
- final List<Integer> listA = new ArrayList<>();
- listA.add(1);
+ assertTrue(!listIterator.hasPrevious());
+ assertTrue(listIterator.hasNext());
- final List<Integer> listB = new ArrayList<>();
- listB.add(2);
+ assertEquals("a", listIterator.next());
- final Closure<List<Integer>> testClosure = ClosureUtils.invokerClosure("clear");
- final Collection<List<Integer>> col = new ArrayList<>();
- col.add(listA);
- col.add(listB);
- List<Integer> last = IteratorUtils.forEachButLast(col.iterator(), testClosure);
- assertTrue(listA.isEmpty() && !listB.isEmpty());
- assertSame(listB, last);
+ assertTrue(listIterator.hasPrevious());
+ assertTrue(listIterator.hasNext());
- try {
- IteratorUtils.forEachButLast(col.iterator(), null);
- fail("expecting NullPointerException");
- } catch (final NullPointerException npe) {
- // expected
- }
+ assertEquals("b", listIterator.next());
- IteratorUtils.forEachButLast(null, testClosure);
+ assertTrue(listIterator.hasPrevious());
+ assertTrue(listIterator.hasNext());
- // null should be OK
- col.add(null);
- col.add(null);
- last = IteratorUtils.forEachButLast(col.iterator(), testClosure);
- assertNull(last);
- }
+ assertEquals("c", listIterator.next());
- @Test
- public void testFind() {
- Predicate<Number> testPredicate = equalPredicate((Number) 4);
- Integer test = IteratorUtils.find(iterableA.iterator(), testPredicate);
- assertTrue(test.equals(4));
- testPredicate = equalPredicate((Number) 45);
- test = IteratorUtils.find(iterableA.iterator(), testPredicate);
- assertTrue(test == null);
- assertNull(IteratorUtils.find(null,testPredicate));
- try {
- assertNull(IteratorUtils.find(iterableA.iterator(), null));
- fail("expecting NullPointerException");
- } catch (final NullPointerException npe) {
- // expected
- }
- }
+ assertTrue(listIterator.hasPrevious());
+ assertTrue(listIterator.hasNext());
- @Test
- public void testIndexOf() {
- Predicate<Number> testPredicate = equalPredicate((Number) 4);
- int index = IteratorUtils.indexOf(iterableA.iterator(), testPredicate);
- assertEquals(6, index);
- testPredicate = equalPredicate((Number) 45);
- index = IteratorUtils.indexOf(iterableA.iterator(), testPredicate);
- assertEquals(-1, index);
- assertEquals(-1, IteratorUtils.indexOf(null, testPredicate));
- try {
- IteratorUtils.indexOf(iterableA.iterator(), null);
- fail("expecting NullPointerException");
- } catch (final NullPointerException npe) {
- // expected
- }
- }
+ assertEquals("d", listIterator.next());
- @Test
- public void testGetAtIndexFromIterator() throws Exception {
- // Iterator, entry exists
- Iterator<Integer> iterator = iterableA.iterator();
- assertEquals(1, (int) IteratorUtils.get(iterator, 0));
- iterator = iterableA.iterator();
- assertEquals(2, (int) IteratorUtils.get(iterator, 1));
+ assertTrue(listIterator.hasPrevious());
+ assertTrue(!listIterator.hasNext());
- // Iterator, non-existent entry
- try {
- IteratorUtils.get(iterator, 10);
- fail("Expecting IndexOutOfBoundsException.");
- } catch (final IndexOutOfBoundsException e) {
- // expected
- }
- assertTrue(!iterator.hasNext());
- }
+ assertEquals("d", listIterator.previous());
- @Test
- public void testFirstFromIterator() throws Exception {
- // Iterator, entry exists
- Iterator<Integer> iterator = iterableA.iterator();
- assertEquals(1, (int) IteratorUtils.first(iterator));
- }
+ assertTrue(listIterator.hasPrevious());
+ assertTrue(listIterator.hasNext());
- @Test
- public void testGetIterator() {
- final Object[] objArray = {"a", "b", "c"};
- final Map<String, String> inMap = new HashMap<>();
- final Node[] nodes = createNodes();
- final NodeList nodeList = createNodeList(nodes);
+ assertEquals("c", listIterator.previous());
- assertTrue("returns empty iterator when null passed", IteratorUtils.getIterator(null) instanceof EmptyIterator);
- assertTrue("returns Iterator when Iterator directly ", IteratorUtils.getIterator(iterableA.iterator()) instanceof Iterator);
- assertTrue("returns Iterator when iterable passed", IteratorUtils.getIterator(iterableA) instanceof Iterator);
- assertTrue("returns ObjectArrayIterator when Object array passed", IteratorUtils.getIterator(objArray) instanceof ObjectArrayIterator);
- assertTrue("returns Iterator when Map passed", IteratorUtils.getIterator(inMap) instanceof Iterator);
- assertTrue("returns NodeListIterator when nodeList passed", IteratorUtils.getIterator(nodeList) instanceof NodeListIterator);
- assertTrue("returns EnumerationIterator when Enumeration passed", IteratorUtils.getIterator(new Vector().elements()) instanceof EnumerationIterator);
+ assertTrue(listIterator.hasPrevious());
+ assertTrue(listIterator.hasNext());
- }
+ assertEquals("b", listIterator.previous());
- @Test
- public void testToListIterator() {
- final List<Integer> list = new ArrayList<>();
- list.add(Integer.valueOf(0));
- list.add(Integer.valueOf(1));
- list.add(Integer.valueOf(2));
- final Iterator<Integer> iterator = list.iterator();
+ assertTrue(listIterator.hasPrevious());
+ assertTrue(listIterator.hasNext());
- final ListIterator<Integer> liItr = IteratorUtils.toListIterator(iterator);
- int expected = 0;
- while(liItr.hasNext()){
- assertEquals(expected, liItr.next().intValue());
- ++expected;
- }
- }
+ assertEquals("a", listIterator.previous());
- @Test
- public void testToListIteratorNull() {
- try {
- IteratorUtils.toListIterator(null);
- fail("Expecting NullPointerException");
- } catch (final NullPointerException ex) {
- // success
- }
+ assertTrue(!listIterator.hasPrevious());
+ assertTrue(listIterator.hasNext());
}
}