[Plexus-svn] SF.net SVN: plexus:[899] trunk/plexus-graph/src/test/java/com/phoenixst/ plexus/Abstr
Status: Alpha
Brought to you by:
rconner
Menu
▾
▴
[Plexus-svn] SF.net SVN: plexus:[899] trunk/plexus-graph/src/test/java/com/phoenixst/ plexus/AbstractGraphTest.java
|
From: <rc...@us...> - 2010-09-16 17:56:36
|
Revision: 899
http://plexus.svn.sourceforge.net/plexus/?rev=899&view=rev
Author: rconner
Date: 2010-09-16 17:56:29 +0000 (Thu, 16 Sep 2010)
Log Message:
-----------
migrate to matcher idiom for tests
Modified Paths:
--------------
trunk/plexus-graph/src/test/java/com/phoenixst/plexus/AbstractGraphTest.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-16 17:49:36 UTC (rev 898)
+++ trunk/plexus-graph/src/test/java/com/phoenixst/plexus/AbstractGraphTest.java 2010-09-16 17:56:29 UTC (rev 899)
@@ -15,12 +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.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.hamcrest.CoreMatchers.nullValue;
+import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
+import static org.junit.matchers.JUnitMatchers.hasItem;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
@@ -44,6 +45,7 @@
*
* @author rconner
*/
+@SuppressWarnings( { "boxing", "PMD.TooManyStaticImports" } )
public abstract class AbstractGraphTest
{
@@ -61,25 +63,25 @@
/**
* The <code>Graph</code> to be tested.
*/
- private Graph g = null;
+ private Graph g;
/**
* Contains all nodes accessed by the graph's
* <code>nodes( null ).iterator()</code> method.
*/
- private Set< Object > nodes = null;
+ private Set< Object > nodes;
/**
* Contains all edges accessed by the graph's
* <code>edges( null ).iterator()</code> method.
*/
- private Set< Edge > realEdges = null;
+ private Set< Edge > realEdges;
/**
* Contains <code>SimpleObjectEdges</code> corresponding to all edges
* accessed by the graph's <code>edges( null ).iterator()</code> method.
*/
- private Set< Edge > testEdges = null;
+ private Set< Edge > testEdges;
/**
*
@@ -128,7 +130,7 @@
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( createEdge( edge ) );
}
}
@@ -196,13 +198,13 @@
Object tail = Integer.valueOf( tailIndex );
for( int headIndex = 0; headIndex < limit; headIndex++ ) {
Object head = Integer.valueOf( headIndex );
- Edge edge = new SimpleObjectEdge( null, tail, head, false );
+ Edge edge = createEdge( null, tail, head, false );
if( pred.evaluate( edge ) ) {
goodEdges.add( edge );
} else {
badEdges.add( edge );
}
- edge = new SimpleObjectEdge( null, tail, head, true );
+ edge = createEdge( null, tail, head, true );
if( pred.evaluate( edge ) ) {
goodEdges.add( edge );
} else {
@@ -226,13 +228,13 @@
for( int headA = 0; headA < limitA; headA++ ) {
for( int headB = 0; headB < limitB; headB++ ) {
Object head = new OrderedIntPair( headA, headB );
- Edge edge = new SimpleObjectEdge( null, tail, head, false );
+ Edge edge = createEdge( null, tail, head, false );
if( pred.evaluate( edge ) ) {
goodEdges.add( edge );
} else {
badEdges.add( edge );
}
- edge = new SimpleObjectEdge( null, tail, head, true );
+ edge = createEdge( null, tail, head, true );
if( pred.evaluate( edge ) ) {
goodEdges.add( edge );
} else {
@@ -289,6 +291,16 @@
// Helper methods
////////////////////////////////////////
+ protected static Edge createEdge( final Edge edge )
+ {
+ return new SimpleObjectEdge( edge.getUserObject(), edge.getTail(), edge.getHead(), edge.isDirected() );
+ }
+
+ protected static Edge createEdge( final Object object, final Object tail, final Object head, final boolean isDirected )
+ {
+ return new SimpleObjectEdge( object, tail, head, isDirected );
+ }
+
private static boolean isSelfEdge( final Edge edge )
{
Object tail = edge.getTail();
@@ -302,31 +314,31 @@
Object edgeHead = edge.getHead();
// Check that the edge endpoints are in the graph.
- assertTrue( g.containsNode( edgeTail ) );
- assertTrue( g.containsNode( edgeHead ) );
- assertTrue( nodes.contains( edgeTail ) );
- assertTrue( nodes.contains( edgeHead ) );
+ assertThat( g.containsNode( edgeTail ), is( true ) );
+ assertThat( g.containsNode( edgeHead ), is( true ) );
+ assertThat( nodes.contains( edgeTail ), is( true ) );
+ assertThat( nodes.contains( edgeHead ), is( true ) );
// Check that the edge, actually goes from tail to head.
if( edge.isDirected() ) {
- assertEquals( tail, edgeTail );
- assertEquals( head, edgeHead );
+ assertThat( edgeTail, is( tail ) );
+ assertThat( edgeHead, is( head ) );
} else {
if( ( tail == null ) ? ( edgeTail == null ) : tail.equals( edgeTail ) ) {
- assertEquals( head, edgeHead );
+ assertThat( edgeHead, is( head ) );
} else {
- assertEquals( tail, edgeHead );
- assertEquals( head, edgeTail );
+ assertThat( edgeHead, is( tail ) );
+ assertThat( edgeTail, is( head ) );
}
}
// 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() ) ) );
+ assertThat( realEdges, hasItem( edge ) );
+ assertThat( testEdges, hasItem( createEdge( edge.getUserObject(), tail, head, edge.isDirected() ) ) );
// Check that getOtherEndpoint() works.
- assertEquals( tail, edge.getOtherEndpoint( head ) );
- assertEquals( head, edge.getOtherEndpoint( tail ) );
+ assertThat( edge.getOtherEndpoint( head ), is( tail ) );
+ assertThat( edge.getOtherEndpoint( tail ), is( head ) );
for( Object node : notPresentNodes ) {
try {
@@ -366,13 +378,13 @@
@Test
public void testNodeSize()
{
- assertEquals( nodes.size(), g.nodes( null ).size() );
+ assertThat( g.nodes( null ).size(), is( nodes.size() ) );
}
@Test
public void testEdgeSize()
{
- assertEquals( realEdges.size(), g.edges( null ).size() );
+ assertThat( g.edges( null ).size(), is( realEdges.size() ) );
}
@Test
@@ -390,7 +402,7 @@
count++;
}
}
- assertEquals( count, g.degree( node ) );
+ assertThat( g.degree( node ), is( count ) );
}
validateNotPresentNodes( new Closure()
@@ -413,7 +425,7 @@
for( count = 0; t.hasNext(); count++ ) {
t.next();
}
- assertEquals( count, g.degree( node, GraphUtils.OUT_TRAVERSER_PREDICATE ) );
+ assertThat( g.degree( node, GraphUtils.OUT_TRAVERSER_PREDICATE ), is( count ) );
}
validateNotPresentNodes( new Closure()
@@ -436,7 +448,7 @@
for( count = 0; t.hasNext(); count++ ) {
t.next();
}
- assertEquals( count, g.degree( node, GraphUtils.IN_TRAVERSER_PREDICATE ) );
+ assertThat( g.degree( node, GraphUtils.IN_TRAVERSER_PREDICATE ), is( count ) );
}
validateNotPresentNodes( new Closure()
@@ -454,15 +466,15 @@
// Check that every node accessed by the node iterator is
// present in the graph.
for( Object node : g.nodes( null ) ) {
- assertTrue( g.containsNode( node ) );
+ assertThat( g.containsNode( node ), is( true ) );
}
// Check for supposedly present and not present nodes.
for( Object node : presentNodes ) {
- assertTrue( g.containsNode( node ) );
+ assertThat( g.containsNode( node ), is( true ) );
}
for( Object node : notPresentNodes ) {
- assertFalse( g.containsNode( node ) );
+ assertThat( g.containsNode( node ), is( false ) );
}
}
@@ -473,7 +485,7 @@
// Check that every edge accessed by the edge iterator is
// present in the graph.
for( Edge edge : (Collection< Edge >) g.edges( null ) ) {
- assertTrue( g.containsEdge( edge ) );
+ assertThat( g.containsEdge( edge ), is( true ) );
}
}
@@ -494,11 +506,11 @@
// Check for supposedly present and not present edges.
for( Edge edge : presentEdges ) {
Predicate edgePred = EdgePredicateFactory.create( edge );
- assertNotNull( g.getEdge( edgePred ) );
+ assertThat( g.getEdge( edgePred ), notNullValue() );
}
for( Edge edge : notPresentEdges ) {
Predicate edgePred = EdgePredicateFactory.create( edge );
- assertNull( g.getEdge( edgePred ) );
+ assertThat( g.getEdge( edgePred ), nullValue() );
}
}
@@ -506,10 +518,10 @@
public void testNodeIterator()
{
for( Object node : presentNodes ) {
- assertTrue( nodes.contains( node ) );
+ assertThat( nodes, hasItem( node ) );
}
for( Object node : notPresentNodes ) {
- assertFalse( nodes.contains( node ) );
+ assertThat( nodes, not( hasItem( node ) ) );
}
Iterator< ? > nodeIter = g.nodes( null ).iterator();
@@ -524,19 +536,17 @@
// Do nothing
}
- assertEquals( count, nodes.size() );
+ assertThat( nodes.size(), is( count ) );
}
@Test
public void testEdgeIterator()
{
for( Edge edge : presentEdges ) {
- assertTrue( testEdges.contains( new SimpleObjectEdge( edge.getUserObject(), edge.getTail(), edge.getHead(),
- edge.isDirected() ) ) );
+ assertThat( testEdges, hasItem( createEdge( edge ) ) );
}
for( Edge edge : notPresentEdges ) {
- assertFalse( testEdges.contains( new SimpleObjectEdge( edge.getUserObject(), edge.getTail(),
- edge.getHead(), edge.isDirected() ) ) );
+ assertThat( testEdges, not( hasItem( createEdge( edge ) ) ) );
}
Iterator< ? > edgeIter = g.edges( null ).iterator();
@@ -552,7 +562,7 @@
// Do nothing
}
- assertEquals( count, realEdges.size() );
+ assertThat( realEdges.size(), is( count ) );
}
@Test
@@ -565,9 +575,9 @@
Predicate edgePred = EdgePredicateFactory.createEqualsNodes( tail, head, DIR_MASK );
Iterator< ? > edgeIter = g.edges( edgePred ).iterator();
if( edgeIter.hasNext() ) {
- assertNotNull( g.getEdge( edgePred ) );
+ assertThat( g.getEdge( edgePred ), notNullValue() );
} else {
- assertNull( g.getEdge( edgePred ) );
+ assertThat( g.getEdge( edgePred ), nullValue() );
}
while( edgeIter.hasNext() ) {
Edge edge = (Edge) edgeIter.next();
@@ -591,19 +601,19 @@
}
}
- assertEquals( totalCount + selfCount, 2 * realEdges.size() );
+ assertThat( totalCount + selfCount, is( 2 * realEdges.size() ) );
// Check for supposedly present and not present edges.
for( Edge edge : presentEdges ) {
Predicate edgePred = EdgePredicateFactory.create( edge );
Iterator< ? > edgeIter = g.edges( edgePred ).iterator();
- assertTrue( edgeIter.hasNext() );
- assertNotNull( edgeIter.next() );
+ assertThat( edgeIter.hasNext(), is( true ) );
+ assertThat( edgeIter.next(), notNullValue() );
}
for( Edge edge : notPresentEdges ) {
Predicate edgePred = EdgePredicateFactory.create( edge );
Iterator< ? > edgeIter = g.edges( edgePred ).iterator();
- assertFalse( edgeIter.hasNext() );
+ assertThat( edgeIter.hasNext(), is( false ) );
}
}
@@ -623,8 +633,8 @@
Object adjNode = t.next();
// Check that the adjacent node is in the graph.
- assertTrue( g.containsNode( adjNode ) );
- assertTrue( nodes.contains( adjNode ) );
+ assertThat( g.containsNode( adjNode ), is( true ) );
+ assertThat( nodes, hasItem( adjNode ) );
Edge edge = t.getEdge();
if( isSelfEdge( edge ) ) {
@@ -646,10 +656,10 @@
}
// Check that each edge accessed by the traverser is unique.
- assertEquals( count, edges.size() );
+ assertThat( edges.size(), is( count ) );
}
- assertEquals( totalCount + selfCount, 2 * realEdges.size() );
+ assertThat( totalCount + selfCount, is( 2 * realEdges.size() ) );
validateNotPresentNodes( new Closure()
{
@@ -674,8 +684,8 @@
Object adjNode = t.next();
// Check that the adjacent node is in the graph.
- assertTrue( g.containsNode( adjNode ) );
- assertTrue( nodes.contains( adjNode ) );
+ assertThat( g.containsNode( adjNode ), is( true ) );
+ assertThat( nodes, hasItem( adjNode ) );
Edge edge = t.getEdge();
edges.add( edge );
@@ -689,7 +699,7 @@
}
// Check that each edge accessed by the traverser is unique.
- assertEquals( count, edges.size() );
+ assertThat( edges.size(), is( count ) );
}
validateNotPresentNodes( new Closure()
@@ -715,8 +725,8 @@
Object adjNode = t.next();
// Check that the adjacent node is in the graph.
- assertTrue( g.containsNode( adjNode ) );
- assertTrue( nodes.contains( adjNode ) );
+ assertThat( g.containsNode( adjNode ), is( true ) );
+ assertThat( nodes, hasItem( adjNode ) );
Edge edge = t.getEdge();
edges.add( edge );
@@ -730,7 +740,7 @@
}
// Check that each edge accessed by the traverser is unique.
- assertEquals( count, edges.size() );
+ assertThat( edges.size(), is( count ) );
}
validateNotPresentNodes( new Closure()
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
