@Before
public void prepareFixture() throws Exception {
Class<AbstractNodeIteratingGraphTraverser> traverserClass =
AbstractNodeIteratingGraphTraverser.class;
traverser =
createMock(
traverserClass,
traverserClass.getMethod("hasNext", (Class[]) null),
traverserClass.getMethod("next", (Class[]) null),
traverserClass.getDeclaredMethod("enqueueNodes", Collection.class));
// creating the mock doesn't initialize instance fields, for some reason
ReflectionUtils.setValue(
traverser, "nodeVisitors", new ArrayList<NodeVisitor<Object, StringBuilder>>());
ReflectionUtils.setValue(traverser, "visitedOrQueuedNodes", new HashSet<Object>());
}
@Test
public void addNode_node_seen() throws IllegalAccessException {
ReflectionUtils.setValue(traverser, "visitedOrQueuedNodes", SetUtils.asSet(1));
// expect no calls to enqueue
traverser.addNode(1);
}
@Test
public void addNode_nodes_seen() throws IllegalAccessException {
ReflectionUtils.setValue(traverser, "visitedOrQueuedNodes", SetUtils.asSet(1));
traverser.enqueueNodes(colEq(Arrays.asList(2)));
expectLastCall();
replay(traverser);
traverser.addNode(Arrays.asList(1, 2));
verify(traverser);
}
/**
* Starting from a node 1, traverse the graph. Node 1 discovers two extra nodes, 1 and 2, of which
* only 2 should be called.
*
* <p>Ensures that any state maintained during traversal is cleared.
*/
@Test
public void traverseFrom_node() throws IllegalAccessException {
traverser.addNodeVisitor(visitor1);
// initially, node 1 will be queued
traverser.enqueueNodes(colEq(Arrays.<Object>asList(1)));
expectLastCall();
traverser.hasNext();
expectLastCall().andReturn(true);
traverser.next();
expectLastCall().andReturn(1);
StringBuilder traversalState = new StringBuilder();
visitor1.visitNode(1, traverser, traversalState);
expectLastCall()
.andAnswer(new NodeVisitorAction(traverser, Arrays.<Object>asList(1, 2), "James", true));
// the second node 1 should not be enqueued
traverser.enqueueNodes(colEq(Arrays.<Object>asList(2)));
expectLastCall();
traverser.hasNext();
expectLastCall().andReturn(true);
traverser.next();
expectLastCall().andReturn(2);
// the visitor should *not* be called again for node 1
visitor1.visitNode(2, traverser, traversalState);
expectLastCall().andAnswer(new NodeVisitorAction(traverser, null, " Bond", true));
// all nodes have been visited
traverser.hasNext();
expectLastCall().andReturn(false);
replay(traverser, visitor1);
// none of the visitors returned "false", so the traversal should succeed
assertTrue(traverser.traverseFrom(1, traversalState));
verify(traverser, visitor1);
// check that the state object was correctly updated
assertEquals("James Bond", traversalState.toString());
// check that any internal state maintained during the cloning has been cleaned up
assertTrue(ReflectionUtils.<Set<?>>getValue(traverser, "visitedOrQueuedNodes").isEmpty());
}
/**
* Starting from nodes 1, 1 and 2, traverse the graph. Node 1 will be called twice because it is
* specified with the starting nodes, and the second visitor is not called for node 2 because the
* first one aborts the traversal.
*
* <p>This also tests that the visitors are called in the expected order, and ensures that any
* state maintained during traversal is cleared.
*/
@Test
public void traverseFrom_nodes() throws IllegalAccessException {
traverser.addNodeVisitor(visitor1);
traverser.addNodeVisitor(visitor2);
// initially, nodes 1, 1 and 2 will be queued
traverser.enqueueNodes(colEq(Arrays.<Object>asList(1, 1, 2)));
expectLastCall();
StringBuilder traversalState = new StringBuilder();
/*
* The visitors will also be called for the *second* 1 (even though it is equal
* to the previous one), because it was specified with the initial objects.
*/
traverser.hasNext();
expectLastCall().andReturn(true).times(2);
traverser.next();
expectLastCall().andReturn(1).times(2);
visitor1.visitNode(1, traverser, traversalState);
expectLastCall().andAnswer(new NodeVisitorAction(traverser, null, null, true)).times(2);
visitor2.visitNode(1, traverser, traversalState);
expectLastCall().andAnswer(new NodeVisitorAction(traverser, null, null, true)).times(2);
// graph traversal is aborted by visitor1, so no further call to visitor2 is expected
traverser.hasNext();
expectLastCall().andReturn(true);
traverser.next();
expectLastCall().andReturn(2);
visitor1.visitNode(2, traverser, traversalState);
expectLastCall().andAnswer(new NodeVisitorAction(traverser, null, null, false));
replay(traverser, visitor1, visitor2);
// of the visitors returned "false", so the traversal should have failed
assertFalse(traverser.traverseFrom(Arrays.<Object>asList(1, 1, 2), traversalState));
verify(traverser, visitor1, visitor2);
// check that the state object was not updated
assertEquals("", traversalState.toString());
// check that any internal state maintained during the cloning has been cleaned up
assertTrue(ReflectionUtils.<Set<?>>getValue(traverser, "visitedOrQueuedNodes").isEmpty());
}