Sort members.
This commit is contained in:
Gary Gregory
parent
8accf274ba
commit
864fda4370
|
|
@ -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() {
|
||||
|
|
@ -97,125 +153,6 @@ public class IteratorUtilsTest {
|
|||
collectionOdd = Arrays.asList(1, 3, 5, 7, 9, 11);
|
||||
}
|
||||
|
||||
@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"};
|
||||
|
|
@ -500,29 +437,124 @@ 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);
|
||||
|
||||
// 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
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets an immutable ListIterator operating on the elements ["a", "b", "c", "d"].
|
||||
* Tests methods collatedIterator(...)
|
||||
*/
|
||||
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());
|
||||
@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);
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------
|
||||
|
|
@ -709,297 +741,28 @@ 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());
|
||||
|
||||
assertEquals("b", iterator.next());
|
||||
|
||||
assertTrue(iterator.hasNext());
|
||||
|
||||
assertEquals("c", iterator.next());
|
||||
|
||||
assertTrue(iterator.hasNext());
|
||||
|
||||
assertEquals("d", iterator.next());
|
||||
|
||||
assertTrue(!iterator.hasNext());
|
||||
}
|
||||
|
||||
/**
|
||||
* 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());
|
||||
|
||||
assertEquals("a", listIterator.next());
|
||||
|
||||
assertTrue(listIterator.hasPrevious());
|
||||
assertTrue(listIterator.hasNext());
|
||||
|
||||
assertEquals("b", listIterator.next());
|
||||
|
||||
assertTrue(listIterator.hasPrevious());
|
||||
assertTrue(listIterator.hasNext());
|
||||
|
||||
assertEquals("c", listIterator.next());
|
||||
|
||||
assertTrue(listIterator.hasPrevious());
|
||||
assertTrue(listIterator.hasNext());
|
||||
|
||||
assertEquals("d", listIterator.next());
|
||||
|
||||
assertTrue(listIterator.hasPrevious());
|
||||
assertTrue(!listIterator.hasNext());
|
||||
|
||||
assertEquals("d", listIterator.previous());
|
||||
|
||||
assertTrue(listIterator.hasPrevious());
|
||||
assertTrue(listIterator.hasNext());
|
||||
|
||||
assertEquals("c", listIterator.previous());
|
||||
|
||||
assertTrue(listIterator.hasPrevious());
|
||||
assertTrue(listIterator.hasNext());
|
||||
|
||||
assertEquals("b", listIterator.previous());
|
||||
|
||||
assertTrue(listIterator.hasPrevious());
|
||||
assertTrue(listIterator.hasNext());
|
||||
|
||||
assertEquals("a", listIterator.previous());
|
||||
|
||||
assertTrue(!listIterator.hasPrevious());
|
||||
assertTrue(listIterator.hasNext());
|
||||
}
|
||||
|
||||
/**
|
||||
* Test remove() for an immutable Iterator.
|
||||
*/
|
||||
@Test
|
||||
public void testUnmodifiableIteratorImmutability() {
|
||||
final Iterator<String> iterator = getImmutableIterator();
|
||||
|
||||
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 {
|
||||
iterator.remove();
|
||||
// We shouldn't get to here.
|
||||
fail("remove() should throw an UnsupportedOperationException");
|
||||
} catch (final UnsupportedOperationException e) {
|
||||
// This is correct; ignore the exception.
|
||||
}
|
||||
|
||||
iterator.next();
|
||||
|
||||
try {
|
||||
iterator.remove();
|
||||
// We shouldn't get to here.
|
||||
fail("remove() should throw an UnsupportedOperationException");
|
||||
} catch (final UnsupportedOperationException e) {
|
||||
// This is correct; ignore the exception.
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Test remove() for an immutable ListIterator.
|
||||
*/
|
||||
@Test
|
||||
public void testUnmodifiableListIteratorImmutability() {
|
||||
final ListIterator<String> listIterator = getImmutableListIterator();
|
||||
|
||||
try {
|
||||
listIterator.remove();
|
||||
// We shouldn't get to here.
|
||||
fail("remove() should throw an UnsupportedOperationException");
|
||||
} catch (final UnsupportedOperationException e) {
|
||||
// This is correct; ignore the exception.
|
||||
}
|
||||
|
||||
try {
|
||||
listIterator.set("a");
|
||||
// We shouldn't get to here.
|
||||
fail("set(Object) should throw an UnsupportedOperationException");
|
||||
} catch (final UnsupportedOperationException e) {
|
||||
// This is correct; ignore the exception.
|
||||
}
|
||||
|
||||
try {
|
||||
listIterator.add("a");
|
||||
// We shouldn't get to here.
|
||||
fail("add(Object) should throw an UnsupportedOperationException");
|
||||
} catch (final UnsupportedOperationException e) {
|
||||
// This is correct; ignore the exception.
|
||||
}
|
||||
|
||||
listIterator.next();
|
||||
|
||||
try {
|
||||
listIterator.remove();
|
||||
// We shouldn't get to here.
|
||||
fail("remove() should throw an UnsupportedOperationException");
|
||||
} catch (final UnsupportedOperationException e) {
|
||||
// This is correct; ignore the exception.
|
||||
}
|
||||
|
||||
try {
|
||||
listIterator.set("a");
|
||||
// We shouldn't get to here.
|
||||
fail("set(Object) should throw an UnsupportedOperationException");
|
||||
} catch (final UnsupportedOperationException e) {
|
||||
// This is correct; ignore the exception.
|
||||
}
|
||||
|
||||
try {
|
||||
listIterator.add("a");
|
||||
// We shouldn't get to here.
|
||||
fail("add(Object) should throw an UnsupportedOperationException");
|
||||
} catch (final UnsupportedOperationException e) {
|
||||
// This is correct; ignore the exception.
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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
|
||||
public void testCollatedIterator() {
|
||||
try {
|
||||
IteratorUtils.collatedIterator(null, collectionOdd.iterator(), null);
|
||||
assertNull(IteratorUtils.find(iterableA.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 testFirstFromIterator() throws Exception {
|
||||
// Iterator, entry exists
|
||||
Iterator<Integer> iterator = iterableA.iterator();
|
||||
assertEquals(1, (int) IteratorUtils.first(iterator));
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
|
|
@ -1064,20 +827,37 @@ public class IteratorUtilsTest {
|
|||
}
|
||||
|
||||
@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));
|
||||
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));
|
||||
|
||||
// Iterator, non-existent entry
|
||||
try {
|
||||
assertNull(IteratorUtils.find(iterableA.iterator(), null));
|
||||
fail("expecting NullPointerException");
|
||||
} catch (final NullPointerException npe) {
|
||||
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("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);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -1097,46 +877,102 @@ public class IteratorUtilsTest {
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests method nodeListIterator(Node)
|
||||
*/
|
||||
@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));
|
||||
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);
|
||||
|
||||
// Iterator, non-existent entry
|
||||
try {
|
||||
IteratorUtils.get(iterator, 10);
|
||||
fail("Expecting IndexOutOfBoundsException.");
|
||||
} catch (final IndexOutOfBoundsException e) {
|
||||
// expected
|
||||
final Iterator<Node> iterator = IteratorUtils.nodeListIterator(parentNode);
|
||||
int expectedNodeIndex = 0;
|
||||
for (final Node actual : IteratorUtils.asIterable(iterator)) {
|
||||
assertEquals(nodes[expectedNodeIndex], actual);
|
||||
++expectedNodeIndex;
|
||||
}
|
||||
assertTrue(!iterator.hasNext());
|
||||
|
||||
// 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(NodeList)
|
||||
*/
|
||||
@Test
|
||||
public void testFirstFromIterator() throws Exception {
|
||||
// Iterator, entry exists
|
||||
Iterator<Integer> iterator = iterableA.iterator();
|
||||
assertEquals(1, (int) IteratorUtils.first(iterator));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetIterator() {
|
||||
final Object[] objArray = {"a", "b", "c"};
|
||||
final Map<String, String> inMap = new HashMap<>();
|
||||
public void testNodeListIterator() {
|
||||
final Node[] nodes = createNodes();
|
||||
final NodeList nodeList = createNodeList(nodes);
|
||||
|
||||
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);
|
||||
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
|
||||
|
|
@ -1165,4 +1001,168 @@ public class IteratorUtilsTest {
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test remove() for an immutable Iterator.
|
||||
*/
|
||||
@Test
|
||||
public void testUnmodifiableIteratorImmutability() {
|
||||
final Iterator<String> iterator = getImmutableIterator();
|
||||
|
||||
try {
|
||||
iterator.remove();
|
||||
// We shouldn't get to here.
|
||||
fail("remove() should throw an UnsupportedOperationException");
|
||||
} catch (final UnsupportedOperationException e) {
|
||||
// This is correct; ignore the exception.
|
||||
}
|
||||
|
||||
iterator.next();
|
||||
|
||||
try {
|
||||
iterator.remove();
|
||||
// We shouldn't get to here.
|
||||
fail("remove() should throw an UnsupportedOperationException");
|
||||
} catch (final UnsupportedOperationException e) {
|
||||
// This is correct; ignore the exception.
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
@Test
|
||||
public void testUnmodifiableListIteratorImmutability() {
|
||||
final ListIterator<String> listIterator = getImmutableListIterator();
|
||||
|
||||
try {
|
||||
listIterator.remove();
|
||||
// We shouldn't get to here.
|
||||
fail("remove() should throw an UnsupportedOperationException");
|
||||
} catch (final UnsupportedOperationException e) {
|
||||
// This is correct; ignore the exception.
|
||||
}
|
||||
|
||||
try {
|
||||
listIterator.set("a");
|
||||
// We shouldn't get to here.
|
||||
fail("set(Object) should throw an UnsupportedOperationException");
|
||||
} catch (final UnsupportedOperationException e) {
|
||||
// This is correct; ignore the exception.
|
||||
}
|
||||
|
||||
try {
|
||||
listIterator.add("a");
|
||||
// We shouldn't get to here.
|
||||
fail("add(Object) should throw an UnsupportedOperationException");
|
||||
} catch (final UnsupportedOperationException e) {
|
||||
// This is correct; ignore the exception.
|
||||
}
|
||||
|
||||
listIterator.next();
|
||||
|
||||
try {
|
||||
listIterator.remove();
|
||||
// We shouldn't get to here.
|
||||
fail("remove() should throw an UnsupportedOperationException");
|
||||
} catch (final UnsupportedOperationException e) {
|
||||
// This is correct; ignore the exception.
|
||||
}
|
||||
|
||||
try {
|
||||
listIterator.set("a");
|
||||
// We shouldn't get to here.
|
||||
fail("set(Object) should throw an UnsupportedOperationException");
|
||||
} catch (final UnsupportedOperationException e) {
|
||||
// This is correct; ignore the exception.
|
||||
}
|
||||
|
||||
try {
|
||||
listIterator.add("a");
|
||||
// We shouldn't get to here.
|
||||
fail("add(Object) should throw an UnsupportedOperationException");
|
||||
} catch (final UnsupportedOperationException e) {
|
||||
// This is correct; ignore the exception.
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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());
|
||||
|
||||
assertEquals("a", listIterator.next());
|
||||
|
||||
assertTrue(listIterator.hasPrevious());
|
||||
assertTrue(listIterator.hasNext());
|
||||
|
||||
assertEquals("b", listIterator.next());
|
||||
|
||||
assertTrue(listIterator.hasPrevious());
|
||||
assertTrue(listIterator.hasNext());
|
||||
|
||||
assertEquals("c", listIterator.next());
|
||||
|
||||
assertTrue(listIterator.hasPrevious());
|
||||
assertTrue(listIterator.hasNext());
|
||||
|
||||
assertEquals("d", listIterator.next());
|
||||
|
||||
assertTrue(listIterator.hasPrevious());
|
||||
assertTrue(!listIterator.hasNext());
|
||||
|
||||
assertEquals("d", listIterator.previous());
|
||||
|
||||
assertTrue(listIterator.hasPrevious());
|
||||
assertTrue(listIterator.hasNext());
|
||||
|
||||
assertEquals("c", listIterator.previous());
|
||||
|
||||
assertTrue(listIterator.hasPrevious());
|
||||
assertTrue(listIterator.hasNext());
|
||||
|
||||
assertEquals("b", listIterator.previous());
|
||||
|
||||
assertTrue(listIterator.hasPrevious());
|
||||
assertTrue(listIterator.hasNext());
|
||||
|
||||
assertEquals("a", listIterator.previous());
|
||||
|
||||
assertTrue(!listIterator.hasPrevious());
|
||||
assertTrue(listIterator.hasNext());
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue