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 <[email protected]> Authored: Thu Feb 22 13:30:44 2018 -0700 Committer: Gary Gregory <[email protected]> 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()); } }
