[Plexus-svn] SF.net SVN: plexus:[884] trunk/plexus-graph/src/test/java/com/phoenixst/ plexus
Status: Alpha
Brought to you by:
rconner
Menu
▾
▴
[Plexus-svn] SF.net SVN: plexus:[884] trunk/plexus-graph/src/test/java/com/phoenixst/ plexus
|
From: <rc...@us...> - 2010-09-15 21:00:31
|
Revision: 884
http://plexus.svn.sourceforge.net/plexus/?rev=884&view=rev
Author: rconner
Date: 2010-09-15 21:00:23 +0000 (Wed, 15 Sep 2010)
Log Message:
-----------
Refactoring test code, although the tests are only half-way to JUnit4 usage.
However, the relationship between AbstractGraphTest, SingletonGraphTest, and UtilSuite appears to work. Running the same set of tests for a bunch of different data objects is not terribly clean in JUnit4. JUnit really wants every possible fixture to be a distinct class (this particular Path graph vs. that other Path graph, etc.); and this was the only way I found to avoid an explosion of top-level public classes.
Modified Paths:
--------------
trunk/plexus-graph/src/test/java/com/phoenixst/plexus/AbstractGraphTest.java
trunk/plexus-graph/src/test/java/com/phoenixst/plexus/util/SingletonGraphTest.java
Added Paths:
-----------
trunk/plexus-graph/src/test/java/com/phoenixst/plexus/util/UtilSuite.java
Modified: trunk/plexus-graph/src/test/java/com/phoenixst/plexus/AbstractGraphTest.java
===================================================================
--- trunk/plexus-graph/src/test/java/com/phoenixst/plexus/AbstractGraphTest.java 2010-09-15 16:09:13 UTC (rev 883)
+++ trunk/plexus-graph/src/test/java/com/phoenixst/plexus/AbstractGraphTest.java 2010-09-15 21:00:23 UTC (rev 884)
@@ -1,7 +1,7 @@
/*
* $Id$
*
- * Copyright (C) 1994-2006 by Phoenix Software Technologists,
+ * Copyright (C) 1994-2010 by Phoenix Software Technologists,
* Inc. and others. All rights reserved.
*
* THIS PROGRAM AND DOCUMENTATION IS PROVIDED UNDER THE TERMS OF THE
@@ -15,6 +15,13 @@
package com.phoenixst.plexus;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
@@ -26,81 +33,79 @@
import org.apache.commons.collections.Closure;
import org.apache.commons.collections.Predicate;
+import org.junit.Test;
import com.phoenixst.collections.OrderedPair;
-import com.phoenixst.junit.AbstractCloneableTestCase;
+import com.phoenixst.plexus.Graph.Edge;
/**
- * A {@link Graph} tester.
+ * A {@link Graph} tester.
*
- * @author Ray A. Conner
+ * @author rconner
*/
-public abstract class AbstractGraphTest extends AbstractCloneableTestCase
+public abstract class AbstractGraphTest
{
- protected static final String SHOULD_THROW_MESSAGE = "Should throw an Exception.";
+ private static final String SHOULD_THROW_MESSAGE = "Should throw an Exception.";
- protected static final String SHOULD_THROW_NO_SUCH_ELEMENT_MESSAGE = "Should throw a NoSuchElementException.";
+ private static final String SHOULD_THROW_NO_SUCH_ELEMENT_MESSAGE = "Should throw a NoSuchElementException.";
- protected static final String SHOULD_THROW_ILLEGAL_ARGUMENT_MESSAGE = "Should throw IllegalArgumentException.";
+ private static final String SHOULD_THROW_ILLEGAL_ARGUMENT_MESSAGE = "Should throw IllegalArgumentException.";
/**
- * Everything but directed in.
+ * Everything but directed in.
*/
- protected static final int DIR_MASK = GraphUtils.UNDIRECTED_MASK | GraphUtils.DIRECTED_OUT_MASK;
+ private static final int DIR_MASK = GraphUtils.UNDIRECTED_MASK | GraphUtils.DIRECTED_OUT_MASK;
/**
- * The <code>Graph</code> to be tested.
+ * The <code>Graph</code> to be tested.
*/
- protected Graph g;
+ Graph g = null;
/**
- * Contains all nodes accessed by the graph's
- * <code>nodes( null ).iterator()</code> method.
+ * Contains all nodes accessed by the graph's
+ * <code>nodes( null ).iterator()</code> method.
*/
- private Set nodes = null;
+ private Set< Object > nodes = null;
/**
- * Contains all edges accessed by the graph's
- * <code>edges( null ).iterator()</code> method.
+ * Contains all edges accessed by the graph's
+ * <code>edges( null ).iterator()</code> method.
*/
- private Set realEdges = null;
+ private Set< Edge > realEdges = null;
/**
- * Contains <code>SimpleObjectEdges</code> corresponding to all
- * edges accessed by the graph's <code>edges( null ).iterator()</code>
- * method.
+ * Contains <code>SimpleObjectEdges</code> corresponding to all edges
+ * accessed by the graph's <code>edges( null ).iterator()</code> method.
*/
- private Set testEdges = null;
+ private Set< Edge > testEdges = null;
-
/**
*
*/
- protected Object[] presentNodes;
+ private Object[] presentNodes = new Object[] {};
/**
*
*/
- protected Object[] notPresentNodes;
+ private Object[] notPresentNodes = new Object[] {};
/**
*
*/
- protected Graph.Edge[] presentEdges;
+ private Edge[] presentEdges = new Edge[] {};
/**
*
*/
- protected Graph.Edge[] notPresentEdges;
+ private Edge[] notPresentEdges = new Edge[] {};
////////////////////////////////////////
// Constructor
////////////////////////////////////////
-
protected AbstractGraphTest()
{
super();
@@ -108,96 +113,90 @@
////////////////////////////////////////
- // Fixture method
+ // Fixture methods
////////////////////////////////////////
-
- protected void setUp( Graph graph )
+ @SuppressWarnings( "unchecked" )
+ protected void setGraph( Graph graph )
{
g = graph;
- nodes = new HashSet();
- Iterator nodeIter = g.nodes( null ).iterator();
- while( nodeIter.hasNext() ) {
- nodes.add( nodeIter.next() );
- }
+ nodes = new HashSet< Object >();
+ nodes.addAll( g.nodes( null ) );
- realEdges = new HashSet();
- testEdges = new HashSet();
- Iterator edgeIter = g.edges( null ).iterator();
- while( edgeIter.hasNext() ) {
- Graph.Edge edge = (Graph.Edge) edgeIter.next();
+ realEdges = new HashSet< Edge >();
+ testEdges = new HashSet< Edge >();
+ for( Edge edge : (Collection< Edge >) g.edges( null ) ) {
realEdges.add( edge );
- testEdges.add( new SimpleObjectEdge( edge.getUserObject(),
- edge.getTail(), edge.getHead(),
- edge.isDirected() ) );
+ testEdges.add( new SimpleObjectEdge( edge.getUserObject(), edge.getTail(), edge.getHead(), edge.isDirected() ) );
}
+ }
- presentNodes = new Object[] {};
- notPresentNodes = new Object[] {};
- presentEdges = new Graph.Edge[] {};
- notPresentEdges = new Graph.Edge[] {};
+ protected void setPresentNodes( Object... presentNodes )
+ {
+ this.presentNodes = presentNodes;
}
+ protected void setNotPresentNodes( Object... notPresentNodes )
+ {
+ this.notPresentNodes = notPresentNodes;
+ }
- ////////////////////////////////////////
- // Protected helper methods and stuff
- ////////////////////////////////////////
+ protected void setPresentEdges( Edge... presentEdges )
+ {
+ this.presentEdges = presentEdges;
+ }
-
- protected boolean isSelfEdge( Graph.Edge edge )
+ protected void setNotPresentEdges( Edge... notPresentEdges )
{
- Object tail = edge.getTail();
- Object head = edge.getHead();
- return (tail == null) ? head == null : tail.equals( head );
+ this.notPresentEdges = notPresentEdges;
}
-
protected void createPresentNodeRanges( int limit )
{
- presentNodes = new Object[ limit ];
+ presentNodes = new Object[limit];
for( int i = 0; i < limit; i++ ) {
- presentNodes[i] = new Integer( i );
+ presentNodes[i] = Integer.valueOf( i );
}
- notPresentNodes = new Object[] { null,
- new Object(),
- new Integer( -1 ),
- new Integer( limit ) };
+ notPresentNodes = new Object[]
+ { null,
+ new Object(),
+ Integer.valueOf( -1 ),
+ Integer.valueOf( limit ) };
}
-
protected void createPresentNodeRanges( int limitA, int limitB )
{
- presentNodes = new Object[ limitA * limitB ];
+ presentNodes = new Object[limitA * limitB];
for( int i = 0; i < limitA; i++ ) {
for( int j = 0; j < limitB; j++ ) {
presentNodes[i * limitB + j] = new OrderedIntPair( i, j );
}
}
- notPresentNodes = new Object[] { null,
- new Object(),
- new OrderedIntPair( -1, 0 ),
- new OrderedIntPair( 0, -1 ),
- new OrderedIntPair( limitA, 0 ),
- new OrderedIntPair( limitA - 1, -1 ),
- new OrderedIntPair( 0, limitB ),
- new OrderedIntPair( -1, limitB - 1 ),
- new OrderedIntPair( limitA - 1, limitB ),
- new OrderedIntPair( limitA, limitB - 1 ) };
+ notPresentNodes = new Object[]
+ { null,
+ new Object(),
+ new OrderedIntPair( -1, 0 ),
+ new OrderedIntPair( 0, -1 ),
+ new OrderedIntPair( limitA, 0 ),
+ new OrderedIntPair( limitA - 1, -1 ),
+ new OrderedIntPair( 0, limitB ),
+ new OrderedIntPair( -1, limitB - 1 ),
+ new OrderedIntPair( limitA - 1, limitB ),
+ new OrderedIntPair( limitA, limitB - 1 ) };
}
-
protected void createEdgeArrays( int limit, Predicate pred )
{
- Set goodEdges = new HashSet();
- Set badEdges = new HashSet();
+ Set< Edge > goodEdges = new HashSet< Edge >();
+ Set< Edge > badEdges = new HashSet< Edge >();
for( int tailIndex = 0; tailIndex < limit; tailIndex++ ) {
- Object tail = new Integer( tailIndex );
+ Object tail = Integer.valueOf( tailIndex );
for( int headIndex = 0; headIndex < limit; headIndex++ ) {
- Object head = new Integer( headIndex );
- Graph.Edge edge = new SimpleObjectEdge( null, tail, head, false );
+ Object head = Integer.valueOf( headIndex );
+ Edge edge = new SimpleObjectEdge( null, tail, head, false );
if( pred.evaluate( edge ) ) {
goodEdges.add( edge );
} else {
@@ -216,11 +215,10 @@
notPresentEdges = createEdgeArray( badEdges );
}
-
protected void createEdgeArrays( int limitA, int limitB, Predicate pred )
{
- Set goodEdges = new HashSet();
- Set badEdges = new HashSet();
+ Set< Edge > goodEdges = new HashSet< Edge >();
+ Set< Edge > badEdges = new HashSet< Edge >();
for( int tailA = 0; tailA < limitA; tailA++ ) {
for( int tailB = 0; tailB < limitB; tailB++ ) {
@@ -228,7 +226,7 @@
for( int headA = 0; headA < limitA; headA++ ) {
for( int headB = 0; headB < limitB; headB++ ) {
Object head = new OrderedIntPair( headA, headB );
- Graph.Edge edge = new SimpleObjectEdge( null, tail, head, false );
+ Edge edge = new SimpleObjectEdge( null, tail, head, false );
if( pred.evaluate( edge ) ) {
goodEdges.add( edge );
} else {
@@ -249,17 +247,27 @@
notPresentEdges = createEdgeArray( badEdges );
}
-
- protected Graph.Edge[] createEdgeArray( Collection edges )
+ protected static Edge[] createEdgeArray( Collection< Edge > edges )
{
- Graph.Edge[] edgeArray = new Graph.Edge[ edges.size() ];
+ Edge[] edgeArray = new Edge[edges.size()];
edges.toArray( edgeArray );
return edgeArray;
}
- protected void testEdge( Graph.Edge edge, Object tail, Object head )
+ ////////////////////////////////////////
+ // helper methods
+ ////////////////////////////////////////
+
+ private static boolean isSelfEdge( Edge edge )
{
+ Object tail = edge.getTail();
+ Object head = edge.getHead();
+ return ( tail == null ) ? head == null : tail.equals( head );
+ }
+
+ private void testEdge( Edge edge, Object tail, Object head )
+ {
Object edgeTail = edge.getTail();
Object edgeHead = edge.getHead();
@@ -274,7 +282,7 @@
assertEquals( tail, edgeTail );
assertEquals( head, edgeHead );
} else {
- if( (tail == null) ? (edgeTail == null) : tail.equals( edgeTail ) ) {
+ if( ( tail == null ) ? ( edgeTail == null ) : tail.equals( edgeTail ) ) {
assertEquals( head, edgeHead );
} else {
assertEquals( tail, edgeHead );
@@ -284,17 +292,15 @@
// Check that the edge is accessed by the edge iterator.
assertTrue( realEdges.contains( edge ) );
- assertTrue( testEdges.contains( new SimpleObjectEdge( edge.getUserObject(),
- tail, head,
- edge.isDirected() ) ) );
+ assertTrue( testEdges.contains( new SimpleObjectEdge( edge.getUserObject(), tail, head, edge.isDirected() ) ) );
// Check that getOtherEndpoint() works.
assertEquals( tail, edge.getOtherEndpoint( head ) );
assertEquals( head, edge.getOtherEndpoint( tail ) );
- for( int i = 0; i < notPresentNodes.length; i++ ) {
+ for( Object node : notPresentNodes ) {
try {
- edge.getOtherEndpoint( notPresentNodes[i] );
+ edge.getOtherEndpoint( node );
fail( SHOULD_THROW_ILLEGAL_ARGUMENT_MESSAGE );
} catch( IllegalArgumentException e ) {
// Do nothing
@@ -302,14 +308,13 @@
}
}
-
- protected void testNotPresentNodes( Closure closure )
+ private void testNotPresentNodes( Closure closure )
{
// Check that using nodes not present in the graph throws an
// exception.
- for( int i = 0; i < notPresentNodes.length; i++ ) {
+ for( Object node : notPresentNodes ) {
try {
- closure.execute( notPresentNodes[i] );
+ closure.execute( node );
fail( SHOULD_THROW_MESSAGE );
} catch( ClassCastException e ) {
// Do nothing
@@ -324,79 +329,34 @@
}
- protected void testNotPresentNodes( BinaryClosure bClosure )
- {
- // Check that using nodes not present in the graph throws an
- // exception.
- for( int i = 0; i < notPresentNodes.length; i++ ) {
- for( int j = 0; j < presentNodes.length; j++ ) {
- try {
- bClosure.execute( notPresentNodes[i], presentNodes[j] );
- fail( SHOULD_THROW_MESSAGE );
- } catch( ClassCastException e ) {
- // Do nothing
- } catch( IllegalArgumentException e ) {
- // Do nothing
- } catch( NoSuchNodeException e ) {
- // Do nothing
- }
- try {
- bClosure.execute( presentNodes[j], notPresentNodes[i] );
- fail( SHOULD_THROW_MESSAGE );
- } catch( ClassCastException e ) {
- // Do nothing
- } catch( IllegalArgumentException e ) {
- // Do nothing
- } catch( NoSuchNodeException e ) {
- // Do nothing
- }
- }
- for( int j = 0; j < notPresentNodes.length; j++ ) {
- try {
- bClosure.execute( notPresentNodes[i], notPresentNodes[j] );
- fail( SHOULD_THROW_MESSAGE );
- } catch( ClassCastException e ) {
- // Do nothing
- } catch( IllegalArgumentException e ) {
- // Do nothing
- } catch( NoSuchNodeException e ) {
- // Do nothing
- }
- }
- }
- }
-
-
////////////////////////////////////////
// Public test methods
////////////////////////////////////////
-
+ @Test
public void testNodeSize()
{
assertEquals( nodes.size(), g.nodes( null ).size() );
}
-
+ @Test
public void testEdgeSize()
{
assertEquals( realEdges.size(), g.edges( null ).size() );
}
-
+ @Test
public void testDegree()
{
// Check that the degree of a node is the same as the number
// of edges accessed by the traverser.
- Iterator nodeIter = g.nodes( null ).iterator();
- while( nodeIter.hasNext() ) {
- Object node = nodeIter.next();
+ for( Object node : g.nodes( null ) ) {
int count;
Traverser t = g.traverser( node, null );
for( count = 0; t.hasNext(); count++ ) {
Object adjNode = t.next();
- if( (node == null) ? (adjNode == null) : node.equals( adjNode ) ) {
+ if( ( node == null ) ? ( adjNode == null ) : node.equals( adjNode ) ) {
count++;
}
}
@@ -404,17 +364,20 @@
}
testNotPresentNodes( new Closure()
- { public void execute( Object object ) { g.degree( object ); } } );
+ {
+ public void execute( Object object )
+ {
+ g.degree( object );
+ }
+ } );
}
-
+ @Test
public void testOutDegree()
{
// Check that the out-degree of a node is the same as the
// number of edges accessed by the out-traverser.
- Iterator nodeIter = g.nodes( null ).iterator();
- while( nodeIter.hasNext() ) {
- Object node = nodeIter.next();
+ for( Object node : g.nodes( null ) ) {
int count;
Traverser t = g.traverser( node, GraphUtils.OUT_TRAVERSER_PREDICATE );
for( count = 0; t.hasNext(); count++ ) {
@@ -424,17 +387,20 @@
}
testNotPresentNodes( new Closure()
- { public void execute( Object object ) { g.degree( object, GraphUtils.OUT_TRAVERSER_PREDICATE ); } } );
+ {
+ public void execute( Object object )
+ {
+ g.degree( object, GraphUtils.OUT_TRAVERSER_PREDICATE );
+ }
+ } );
}
-
+ @Test
public void testInDegree()
{
// Check that the in-degree of a node is the same as the
// number of edges accessed by the in-traverser.
- Iterator nodeIter = g.nodes( null ).iterator();
- while( nodeIter.hasNext() ) {
- Object node = nodeIter.next();
+ for( Object node : g.nodes( null ) ) {
int count;
Traverser t = g.traverser( node, GraphUtils.IN_TRAVERSER_PREDICATE );
for( count = 0; t.hasNext(); count++ ) {
@@ -444,51 +410,51 @@
}
testNotPresentNodes( new Closure()
- { public void execute( Object object ) { g.degree( object, GraphUtils.IN_TRAVERSER_PREDICATE ); } } );
+ {
+ public void execute( Object object )
+ {
+ g.degree( object, GraphUtils.IN_TRAVERSER_PREDICATE );
+ }
+ } );
}
-
+ @Test
public void testContainsNode()
{
// Check that every node accessed by the node iterator is
// present in the graph.
- Iterator nodeIter = g.nodes( null ).iterator();
- while( nodeIter.hasNext() ) {
- assertTrue( g.containsNode( nodeIter.next() ) );
+ for( Object node : g.nodes( null ) ) {
+ assertTrue( g.containsNode( node ) );
}
// Check for supposedly present and not present nodes.
- for( int i = 0; i < presentNodes.length; i++ ) {
- assertTrue( g.containsNode( presentNodes[i] ) );
+ for( Object node : presentNodes ) {
+ assertTrue( g.containsNode( node ) );
}
- for( int i = 0; i < notPresentNodes.length; i++ ) {
- assertFalse( g.containsNode( notPresentNodes[i] ) );
+ for( Object node : notPresentNodes ) {
+ assertFalse( g.containsNode( node ) );
}
}
-
+ @Test
+ @SuppressWarnings( "unchecked" )
public void testContainsEdge()
{
// Check that every edge accessed by the edge iterator is
// present in the graph.
- Iterator edgeIter = g.edges( null ).iterator();
- while( edgeIter.hasNext() ) {
- assertTrue( g.containsEdge( (Graph.Edge) edgeIter.next() ) );
+ for( Edge edge : (Collection< Edge >) g.edges( null ) ) {
+ assertTrue( g.containsEdge( edge ) );
}
}
-
+ @Test
public void testGetEdge()
{
// Check an edge for each pair of nodes.
- Iterator tailIter = g.nodes( null ).iterator();
- while( tailIter.hasNext() ) {
- Object tail = tailIter.next();
- Iterator headIter = g.nodes( null ).iterator();
- while( headIter.hasNext() ) {
- Object head = headIter.next();
+ for( Object tail : g.nodes( null ) ) {
+ for( Object head : g.nodes( null ) ) {
Predicate edgePred = EdgePredicateFactory.createEqualsNodes( tail, head, DIR_MASK );
- Graph.Edge edge = g.getEdge( edgePred );
+ Edge edge = g.getEdge( edgePred );
if( edge != null ) {
testEdge( edge, tail, head );
}
@@ -496,29 +462,27 @@
}
// Check for supposedly present and not present edges.
- for( int i = 0; i < presentEdges.length; i++ ) {
- Graph.Edge edge = presentEdges[i];
+ for( Edge edge : presentEdges ) {
Predicate edgePred = EdgePredicateFactory.create( edge );
assertNotNull( g.getEdge( edgePred ) );
}
- for( int i = 0; i < notPresentEdges.length; i++ ) {
- Graph.Edge edge = notPresentEdges[i];
+ for( Edge edge : notPresentEdges ) {
Predicate edgePred = EdgePredicateFactory.create( edge );
assertNull( g.getEdge( edgePred ) );
}
}
-
+ @Test
public void testNodeIterator()
{
- for( int i = 0; i < presentNodes.length; i++ ) {
- assertTrue( nodes.contains( presentNodes[i] ) );
+ for( Object node : presentNodes ) {
+ assertTrue( nodes.contains( node ) );
}
- for( int i = 0; i < notPresentNodes.length; i++ ) {
- assertFalse( nodes.contains( notPresentNodes[i] ) );
+ for( Object node : notPresentNodes ) {
+ assertFalse( nodes.contains( node ) );
}
- Iterator nodeIter = g.nodes( null ).iterator();
+ Iterator< ? > nodeIter = g.nodes( null ).iterator();
int count;
for( count = 0; nodeIter.hasNext(); count++ ) {
nodeIter.next();
@@ -533,27 +497,23 @@
assertEquals( count, nodes.size() );
}
-
+ @Test
public void testEdgeIterator()
{
- for( int i = 0; i < presentEdges.length; i++ ) {
- Graph.Edge edge = presentEdges[i];
- assertTrue( testEdges.contains( new SimpleObjectEdge( edge.getUserObject(),
- edge.getTail(), edge.getHead(),
+ for( Edge edge : presentEdges ) {
+ assertTrue( testEdges.contains( new SimpleObjectEdge( edge.getUserObject(), edge.getTail(), edge.getHead(),
edge.isDirected() ) ) );
}
- for( int i = 0; i < notPresentEdges.length; i++ ) {
- Graph.Edge edge = notPresentEdges[i];
- assertFalse( testEdges.contains( new SimpleObjectEdge( edge.getUserObject(),
- edge.getTail(), edge.getHead(),
- edge.isDirected() ) ) );
+ for( Edge edge : notPresentEdges ) {
+ assertFalse( testEdges.contains( new SimpleObjectEdge( edge.getUserObject(), edge.getTail(),
+ edge.getHead(), edge.isDirected() ) ) );
}
- Iterator edgeIter = g.edges( null ).iterator();
+ Iterator< ? > edgeIter = g.edges( null ).iterator();
int count;
for( count = 0; edgeIter.hasNext(); count++ ) {
- Graph.Edge edge = (Graph.Edge) edgeIter.next();
+ Edge edge = (Edge) edgeIter.next();
testEdge( edge, edge.getTail(), edge.getHead() );
}
try {
@@ -566,26 +526,22 @@
assertEquals( count, realEdges.size() );
}
-
+ @Test
public void testEdgeIterator2()
{
int totalCount = 0;
int selfCount = 0;
- Iterator tailIter = g.nodes( null ).iterator();
- while( tailIter.hasNext() ) {
- Object tail = tailIter.next();
- Iterator headIter = g.nodes( null ).iterator();
- while( headIter.hasNext() ) {
- Object head = headIter.next();
+ for( Object tail : g.nodes( null ) ) {
+ for( Object head : g.nodes( null ) ) {
Predicate edgePred = EdgePredicateFactory.createEqualsNodes( tail, head, DIR_MASK );
- Iterator edgeIter = g.edges( edgePred ).iterator();
+ Iterator< ? > edgeIter = g.edges( edgePred ).iterator();
if( edgeIter.hasNext() ) {
assertNotNull( g.getEdge( edgePred ) );
} else {
assertNull( g.getEdge( edgePred ) );
}
while( edgeIter.hasNext() ) {
- Graph.Edge edge = (Graph.Edge) edgeIter.next();
+ Edge edge = (Edge) edgeIter.next();
if( isSelfEdge( edge ) ) {
selfCount++;
}
@@ -609,30 +565,26 @@
assertEquals( totalCount + selfCount, 2 * realEdges.size() );
// Check for supposedly present and not present edges.
- for( int i = 0; i < presentEdges.length; i++ ) {
- Graph.Edge edge = presentEdges[i];
+ for( Edge edge : presentEdges ) {
Predicate edgePred = EdgePredicateFactory.create( edge );
- Iterator edgeIter = g.edges( edgePred ).iterator();
+ Iterator< ? > edgeIter = g.edges( edgePred ).iterator();
assertTrue( edgeIter.hasNext() );
assertNotNull( edgeIter.next() );
}
- for( int i = 0; i < notPresentEdges.length; i++ ) {
- Graph.Edge edge = notPresentEdges[i];
+ for( Edge edge : notPresentEdges ) {
Predicate edgePred = EdgePredicateFactory.create( edge );
- Iterator edgeIter = g.edges( edgePred ).iterator();
+ Iterator< ? > edgeIter = g.edges( edgePred ).iterator();
assertFalse( edgeIter.hasNext() );
}
}
-
+ @Test
public void testTraverser()
{
int totalCount = 0;
int selfCount = 0;
- HashSet edges = new HashSet();
- Iterator nodeIter = g.nodes( null ).iterator();
- while( nodeIter.hasNext() ) {
- Object node = nodeIter.next();
+ HashSet< Edge > edges = new HashSet< Edge >();
+ for( Object node : g.nodes( null ) ) {
Traverser t = g.traverser( node, null );
edges.clear();
@@ -645,13 +597,13 @@
assertTrue( g.containsNode( adjNode ) );
assertTrue( nodes.contains( adjNode ) );
- Graph.Edge edge = t.getEdge();
+ Edge edge = t.getEdge();
if( isSelfEdge( edge ) ) {
selfCount++;
}
edges.add( edge );
Object tail = edge.getTail();
- if( (node == null) ? (tail == null) : node.equals( tail ) ) {
+ if( ( node == null ) ? ( tail == null ) : node.equals( tail ) ) {
testEdge( edge, node, adjNode );
} else {
testEdge( edge, adjNode, node );
@@ -671,16 +623,19 @@
assertEquals( totalCount + selfCount, 2 * realEdges.size() );
testNotPresentNodes( new Closure()
- { public void execute( Object object ) { g.traverser( object, null ); } } );
+ {
+ public void execute( Object object )
+ {
+ g.traverser( object, null );
+ }
+ } );
}
-
+ @Test
public void testOutTraverser()
{
- HashSet edges = new HashSet();
- Iterator nodeIter = g.nodes( null ).iterator();
- while( nodeIter.hasNext() ) {
- Object node = nodeIter.next();
+ HashSet< Edge > edges = new HashSet< Edge >();
+ for( Object node : g.nodes( null ) ) {
Traverser t = g.traverser( node, GraphUtils.OUT_TRAVERSER_PREDICATE );
edges.clear();
@@ -693,7 +648,7 @@
assertTrue( g.containsNode( adjNode ) );
assertTrue( nodes.contains( adjNode ) );
- Graph.Edge edge = t.getEdge();
+ Edge edge = t.getEdge();
edges.add( edge );
testEdge( edge, node, adjNode );
}
@@ -709,16 +664,19 @@
}
testNotPresentNodes( new Closure()
- { public void execute( Object object ) { g.traverser( object, GraphUtils.OUT_TRAVERSER_PREDICATE ); } } );
+ {
+ public void execute( Object object )
+ {
+ g.traverser( object, GraphUtils.OUT_TRAVERSER_PREDICATE );
+ }
+ } );
}
-
+ @Test
public void testInTraverser()
{
- HashSet edges = new HashSet();
- Iterator nodeIter = g.nodes( null ).iterator();
- while( nodeIter.hasNext() ) {
- Object node = nodeIter.next();
+ HashSet< Edge > edges = new HashSet< Edge >();
+ for( Object node : g.nodes( null ) ) {
Traverser t = g.traverser( node, GraphUtils.IN_TRAVERSER_PREDICATE );
edges.clear();
@@ -731,7 +689,7 @@
assertTrue( g.containsNode( adjNode ) );
assertTrue( nodes.contains( adjNode ) );
- Graph.Edge edge = t.getEdge();
+ Edge edge = t.getEdge();
edges.add( edge );
testEdge( edge, adjNode, node );
}
@@ -747,10 +705,15 @@
}
testNotPresentNodes( new Closure()
- { public void execute( Object object ) { g.traverser( object, GraphUtils.IN_TRAVERSER_PREDICATE ); } } );
+ {
+ public void execute( Object object )
+ {
+ g.traverser( object, GraphUtils.IN_TRAVERSER_PREDICATE );
+ }
+ } );
}
-
+ @Test
public void testSerialization()
throws IOException
{
@@ -763,23 +726,16 @@
////////////////////////////////////////
- // Protected classes and interfaces
+ // Private classes
////////////////////////////////////////
-
- protected interface BinaryClosure
+ private static class OrderedIntPair extends OrderedPair
{
- public void execute( Object a, Object b );
- }
-
-
- protected static class OrderedIntPair extends OrderedPair
- {
private static final long serialVersionUID = 1L;
public OrderedIntPair( int first, int second )
{
- super( new Integer( first ), new Integer( second ) );
+ super( Integer.valueOf( first ), Integer.valueOf( second ) );
}
}
Modified: trunk/plexus-graph/src/test/java/com/phoenixst/plexus/util/SingletonGraphTest.java
===================================================================
--- trunk/plexus-graph/src/test/java/com/phoenixst/plexus/util/SingletonGraphTest.java 2010-09-15 16:09:13 UTC (rev 883)
+++ trunk/plexus-graph/src/test/java/com/phoenixst/plexus/util/SingletonGraphTest.java 2010-09-15 21:00:23 UTC (rev 884)
@@ -1,7 +1,7 @@
/*
* $Id$
*
- * Copyright (C) 1994-2006 by Phoenix Software Technologists,
+ * Copyright (C) 1994-2010 by Phoenix Software Technologists,
* Inc. and others. All rights reserved.
*
* THIS PROGRAM AND DOCUMENTATION IS PROVIDED UNDER THE TERMS OF THE
@@ -15,64 +15,48 @@
package com.phoenixst.plexus.util;
-import junit.framework.*;
+import org.junit.Before;
-import com.phoenixst.plexus.*;
+import com.phoenixst.plexus.AbstractGraphTest;
+import com.phoenixst.plexus.SimpleObjectEdge;
/**
- * A {@link SingletonGraph} tester.
+ * A {@link SingletonGraph} tester.
*
- * @author Ray A. Conner
+ * @author rconner
*/
-public class SingletonGraphTest extends AbstractGraphTest
+public abstract class SingletonGraphTest extends AbstractGraphTest
{
-
- private final Object node;
-
-
- public SingletonGraphTest( Object node )
+ void setNode( Object node )
{
- super();
- this.node = node;
- }
-
-
- @Override
- protected void setUp()
- throws Exception
- {
- super.setUp();
- setUp( new SingletonGraph( node ) );
- presentNodes = new Object[] { node };
+ setGraph( new SingletonGraph( node ) );
+ setPresentNodes( node );
if( node == null ) {
- notPresentNodes = new Object[] { new Object() };
+ setNotPresentNodes( new Object() );
} else {
- notPresentNodes = new Object[] { null, new Object() };
+ setNotPresentNodes( null, new Object() );
}
- notPresentEdges = new Graph.Edge[] { new SimpleObjectEdge( null, node, node, false ),
- new SimpleObjectEdge( null, node, node, true ) };
+ setNotPresentEdges( new SimpleObjectEdge( null, node, node, false ),
+ new SimpleObjectEdge( null, node, node, true ) );
}
- private static Test suite( Object node )
+ public static class TestNull extends SingletonGraphTest
{
- return new SingletonGraphTest( node ).getInstanceSuite( "Singleton[" + node + "]" );
+ @Before
+ public void init()
+ {
+ setNode( null );
+ }
}
-
- public static Test suite()
+ public static class TestInteger extends SingletonGraphTest
{
- TestSuite suite = new TestSuite( "SingletonGraph Tests" );
- suite.addTest( suite( null ) );
- suite.addTest( suite( new Integer( 5 ) ) );
- return suite;
+ @Before
+ public void init()
+ {
+ setNode( Integer.valueOf( 5 ) );
+ }
}
-
-
- public static void main( String[] args )
- {
- junit.textui.TestRunner.run( suite() );
- }
-
}
Added: trunk/plexus-graph/src/test/java/com/phoenixst/plexus/util/UtilSuite.java
===================================================================
--- trunk/plexus-graph/src/test/java/com/phoenixst/plexus/util/UtilSuite.java (rev 0)
+++ trunk/plexus-graph/src/test/java/com/phoenixst/plexus/util/UtilSuite.java 2010-09-15 21:00:23 UTC (rev 884)
@@ -0,0 +1,34 @@
+/*
+ * $Id$
+ *
+ * Copyright (C) 1994-2010 by Phoenix Software Technologists,
+ * Inc. and others. All rights reserved.
+ *
+ * THIS PROGRAM AND DOCUMENTATION IS PROVIDED UNDER THE TERMS OF THE
+ * COMMON PUBLIC LICENSE ("AGREEMENT") WHICH ACCOMPANIES IT. ANY
+ * USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES
+ * RECIPIENT'S ACCEPTANCE OF THE AGREEMENT.
+ *
+ * The license text can also be found at
+ * http://opensource.org/licenses/cpl.php
+ */
+
+package com.phoenixst.plexus.util;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+
+/**
+ * Suite for all the tests in this package.
+ *
+ * @author rconner
+ */
+@RunWith( Suite.class )
+@Suite.SuiteClasses( {
+ SingletonGraphTest.TestNull.class,
+ SingletonGraphTest.TestInteger.class } )
+public class UtilSuite
+{
+ // This class merely exists to hold the JUnit annotations.
+}
Property changes on: trunk/plexus-graph/src/test/java/com/phoenixst/plexus/util/UtilSuite.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: svn:keywords
+ Date Revision Id
Added: svn:eol-style
+ native
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
