Added more unit tests for the graph utilities.

@@ -15,7 +15,7 @@ import static com.google.common.base.Preconditions.checkNotNull;
  * @param <V> vertex type
  * @param <V> vertex type
  * @param <E> edge type
  * @param <E> edge type
  */
  */
-public abstract class AbstractPathSearch<V extends Vertex, E extends Edge<V>>
+public abstract class AbstractGraphPathSearch<V extends Vertex, E extends Edge<V>>
         implements GraphPathSearch<V, E> {
         implements GraphPathSearch<V, E> {
 
 
     private double samenessThreshold = 0.000000001;
     private double samenessThreshold = 0.000000001;

+package org.onlab.graph;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Implementation of the BFS algorithm.
+ */
+public class BreadthFirstSearch<V extends Vertex, E extends Edge<V>>
+        extends AbstractGraphPathSearch<V, E> {
+
+    @Override
+    public Result<V, E> search(Graph<V, E> graph, V src, V dst, EdgeWeight<V, E> ew) {
+        checkArguments(graph, src, dst);
+        
+        // Prepare the graph result.
+        DefaultResult result = new DefaultResult(src, dst);
+
+        // Setup the starting frontier with the source as the sole vertex.
+        Set<V> frontier = new HashSet<>();
+        result.costs.put(src, 0.0);
+        frontier.add(src);
+        
+        search: while (!frontier.isEmpty()) {
+            // Prepare the next frontier.
+            Set<V> next = new HashSet<>();
+
+            // Visit all vertexes in the current frontier.
+            for (V vertex : frontier) {
+                double cost = result.cost(vertex);
+                
+                // Visit all egress edges of the current frontier vertex.
+                for (E edge : graph.getEdgesFrom(vertex)) {
+                    V nextVertex = edge.dst();
+                    if (!result.hasCost(nextVertex)) {
+                        // If this vertex has not been visited yet, update it.
+                        result.updateVertex(nextVertex, edge,
+                                            cost + (ew == null ? 1.0 : ew.weight(edge)),
+                                            true);
+                        // If we have reached our intended destination, bail.
+                        if (nextVertex.equals(dst))
+                            break search;
+                        next.add(nextVertex);
+                    }
+                }
+            }
+            
+            // Promote the next frontier.
+            frontier = next;
+        }
+        
+        // Finally, but the paths on the search result and return.
+        result.buildPaths();
+        return result;
+    }
+    
+}

@@ -14,8 +14,6 @@ import static com.google.common.base.Preconditions.checkNotNull;
  */
  */
 public class DefaultMutablePath<V extends Vertex, E extends Edge<V>> implements MutablePath<V, E> {
 public class DefaultMutablePath<V extends Vertex, E extends Edge<V>> implements MutablePath<V, E> {
 
 
-    private V src = null;
-    private V dst = null;
     private final List<E> edges = new ArrayList<>();
     private final List<E> edges = new ArrayList<>();
     private double cost = 0.0;
     private double cost = 0.0;
 
 
@@ -32,20 +30,18 @@ public class DefaultMutablePath<V extends Vertex, E extends Edge<V>> implements
      */
      */
     public DefaultMutablePath(Path<V, E> path) {
     public DefaultMutablePath(Path<V, E> path) {
         checkNotNull(path, "Path cannot be null");
         checkNotNull(path, "Path cannot be null");
-        this.src = path.src();
-        this.dst = path.dst();
         this.cost = path.cost();
         this.cost = path.cost();
         edges.addAll(path.edges());
         edges.addAll(path.edges());
     }
     }
 
 
     @Override
     @Override
     public V src() {
     public V src() {
-        return src;
+        return edges.isEmpty() ? null : edges.get(0).src();
     }
     }
 
 
     @Override
     @Override
     public V dst() {
     public V dst() {
-        return dst;
+        return edges.isEmpty() ? null : edges.get(edges.size() - 1).dst();
     }
     }
 
 
     @Override
     @Override
@@ -69,28 +65,35 @@ public class DefaultMutablePath<V extends Vertex, E extends Edge<V>> implements
     }
     }
 
 
     @Override
     @Override
+    public void insertEdge(E edge) {
+        checkNotNull(edge, "Edge cannot be null");
+        checkArgument(edges.isEmpty() || src().equals(edge.dst()),
+                      "Edge destination must be the same as the current path source");
+        edges.add(0, edge);
+    }
+
+    @Override
     public void appendEdge(E edge) {
     public void appendEdge(E edge) {
         checkNotNull(edge, "Edge cannot be null");
         checkNotNull(edge, "Edge cannot be null");
-        checkArgument(edges.isEmpty() || dst.equals(edge.src()),
+        checkArgument(edges.isEmpty() || dst().equals(edge.src()),
                       "Edge source must be the same as the current path destination");
                       "Edge source must be the same as the current path destination");
-        dst = edge.dst();
         edges.add(edge);
         edges.add(edge);
     }
     }
 
 
     @Override
     @Override
-    public void insertEdge(E edge) {
-        checkNotNull(edge, "Edge cannot be null");
-        checkArgument(edges.isEmpty() || src.equals(edge.dst()),
-                      "Edge destination must be the same as the current path source");
-        src = edge.src();
-        edges.add(0, edge);
+    public void removeEdge(E edge) {
+        checkArgument(edge.src().equals(edge.dst()) ||
+                              edges.indexOf(edge) == 0 ||
+                              edges.lastIndexOf(edge) == edges.size() - 1,
+                      "Edge must be at start or end of path, or it must be a cyclic edge");
+        edges.remove(edge);
     }
     }
 
 
     @Override
     @Override
     public String toString() {
     public String toString() {
         return com.google.common.base.Objects.toStringHelper(this)
         return com.google.common.base.Objects.toStringHelper(this)
-                .add("src", src)
-                .add("dst", dst)
+                .add("src", src())
+                .add("dst", dst())
                 .add("cost", cost)
                 .add("cost", cost)
                 .add("edges", edges)
                 .add("edges", edges)
                 .toString();
                 .toString();
@@ -98,19 +101,17 @@ public class DefaultMutablePath<V extends Vertex, E extends Edge<V>> implements
 
 
     @Override
     @Override
     public int hashCode() {
     public int hashCode() {
-        return Objects.hash(src, dst, edges, cost);
+        return Objects.hash(edges, cost);
     }
     }
 
 
     @Override
     @Override
     public boolean equals(Object obj) {
     public boolean equals(Object obj) {
         if (obj instanceof DefaultMutablePath) {
         if (obj instanceof DefaultMutablePath) {
             final DefaultMutablePath other = (DefaultMutablePath) obj;
             final DefaultMutablePath other = (DefaultMutablePath) obj;
-            return super.equals(obj) &&
-                    Objects.equals(this.src, other.src) &&
-                    Objects.equals(this.dst, other.dst) &&
-                    Objects.equals(this.cost, other.cost) &&
+            return Objects.equals(this.cost, other.cost) &&
                     Objects.equals(this.edges, other.edges);
                     Objects.equals(this.edges, other.edges);
         }
         }
         return false;
         return false;
     }
     }
+
 }
 }

@@ -73,8 +73,7 @@ public class DefaultPath<V extends Vertex, E extends Edge<V>> implements Path<V,
     public boolean equals(Object obj) {
     public boolean equals(Object obj) {
         if (obj instanceof DefaultPath) {
         if (obj instanceof DefaultPath) {
             final DefaultPath other = (DefaultPath) obj;
             final DefaultPath other = (DefaultPath) obj;
-            return super.equals(obj) &&
-                    Objects.equals(this.src, other.src) &&
+            return Objects.equals(this.src, other.src) &&
                     Objects.equals(this.dst, other.dst) &&
                     Objects.equals(this.dst, other.dst) &&
                     Objects.equals(this.cost, other.cost) &&
                     Objects.equals(this.cost, other.cost) &&
                     Objects.equals(this.edges, other.edges);
                     Objects.equals(this.edges, other.edges);

@@ -9,7 +9,7 @@ import java.util.Set;
  * one, but all shortest paths between the source and destinations.
  * one, but all shortest paths between the source and destinations.
  */
  */
 public class DijkstraGraphSearch<V extends Vertex, E extends Edge<V>>
 public class DijkstraGraphSearch<V extends Vertex, E extends Edge<V>>
-        extends AbstractPathSearch<V, E> {
+        extends AbstractGraphPathSearch<V, E> {
 
 
     @Override
     @Override
     public Result<V, E> search(Graph<V, E> g, V src, V dst, EdgeWeight<V, E> ew) {
     public Result<V, E> search(Graph<V, E> g, V src, V dst, EdgeWeight<V, E> ew) {

@@ -22,6 +22,15 @@ public interface MutablePath<V extends Vertex, E extends Edge<V>> extends Path<V
     void appendEdge(E edge);
     void appendEdge(E edge);
 
 
     /**
     /**
+     * Removes the specified edge. This edge must be either at the start or
+     * at the end of the path, or it must be a cyclic edge in order not to
+     * violate the contiguous path property.
+     *
+     * @param edge edge to be removed
+     */
+    void removeEdge(E edge);
+
+    /**
      * Sets the total path cost as a unit-less double.
      * Sets the total path cost as a unit-less double.
      *
      *
      * @param cost new path cost
      * @param cost new path cost

 package org.onlab.graph;
 package org.onlab.graph;
 
 
-import com.google.common.collect.ImmutableSet;
 import org.junit.Test;
 import org.junit.Test;
 
 
+import static com.google.common.collect.ImmutableSet.of;
+import static org.junit.Assert.assertEquals;
+
 /**
 /**
  * Base for all graph search tests.
  * Base for all graph search tests.
  */
  */
-public abstract class AbstractGraphSearchTest extends GraphTest {
+public abstract class AbstractGraphPathSearchTest extends GraphTest {
 
 
     /**
     /**
-     * Creates a graph search to be tested.
+     * Creates a test-specific graph search to exercise.
      *
      *
      * @return graph search
      * @return graph search
      */
      */
-    protected abstract GraphPathSearch<TestVertex, TestEdge> graphSearch();
+    protected abstract AbstractGraphPathSearch<TestVertex, TestEdge> graphSearch();
 
 
     @Test(expected = IllegalArgumentException.class)
     @Test(expected = IllegalArgumentException.class)
-    public void badSource() {
-        graphSearch().search(new AdjacencyListsGraph<>(ImmutableSet.of(B, C),
-                                                       ImmutableSet.of(new TestEdge(B, C, 1))),
+    public void noSuchSourceArgument() {
+        graphSearch().search(new AdjacencyListsGraph<>(of(B, C),
+                                                       of(new TestEdge(B, C, 1))),
                              A, H, weight);
                              A, H, weight);
     }
     }
 
 
     @Test(expected = NullPointerException.class)
     @Test(expected = NullPointerException.class)
-    public void nullSource() {
-        graphSearch().search(new AdjacencyListsGraph<>(ImmutableSet.of(B, C),
-                                                       ImmutableSet.of(new TestEdge(B, C, 1))),
-                             null, H, weight);
+    public void nullGraphArgument() {
+        graphSearch().search(null, A, H, weight);
     }
     }
 
 
     @Test(expected = NullPointerException.class)
     @Test(expected = NullPointerException.class)
-    public void nullGraph() {
-        graphSearch().search(null, A, H, weight);
+    public void nullSourceArgument() {
+        graphSearch().search(new AdjacencyListsGraph<>(of(B, C),
+                                                       of(new TestEdge(B, C, 1))),
+                             null, H, weight);
+    }
+
+    @Test
+    public void samenessThreshold() {
+        AbstractGraphPathSearch<TestVertex, TestEdge> search = graphSearch();
+        search.setSamenessThreshold(0.3);
+        assertEquals("incorrect threshold", 0.3, search.samenessThreshold(), 0.01);
     }
     }
 
 
 }
 }

@@ -22,22 +22,9 @@ public class AdjacencyListsGraphTest {
     private static final TestVertex G = new TestVertex("G");
     private static final TestVertex G = new TestVertex("G");
 
 
     private final Set<TestEdge> edges =
     private final Set<TestEdge> edges =
-            ImmutableSet.of(new TestEdge(A, B, 1), new TestEdge(A, C, 1),
-                            new TestEdge(B, C, 1), new TestEdge(C, D, 1),
-                            new TestEdge(D, A, 1));
-
-    @Test
-    public void basics() {
-        Set<TestVertex> vertexes = ImmutableSet.of(A, B, C, D, E, F);
-        AdjacencyListsGraph<TestVertex, TestEdge> graph = new AdjacencyListsGraph<>(vertexes, edges);
-        assertEquals("incorrect vertex count", 6, graph.getVertexes().size());
-        assertEquals("incorrect edge count", 5, graph.getEdges().size());
-
-        assertEquals("incorrect egress edge count", 2, graph.getEdgesFrom(A).size());
-        assertEquals("incorrect ingress edge count", 1, graph.getEdgesTo(A).size());
-        assertEquals("incorrect ingress edge count", 2, graph.getEdgesTo(C).size());
-        assertEquals("incorrect egress edge count", 1, graph.getEdgesFrom(C).size());
-    }
+            ImmutableSet.of(new TestEdge(A, B, 1), new TestEdge(B, C, 1),
+                            new TestEdge(C, D, 1), new TestEdge(D, A, 1),
+                            new TestEdge(B, D, 1));
 
 
     @Test
     @Test
     public void equality() {
     public void equality() {
@@ -53,4 +40,18 @@ public class AdjacencyListsGraphTest {
                 .addEqualityGroup(different)
                 .addEqualityGroup(different)
                 .testEquals();
                 .testEquals();
     }
     }
+
+    @Test
+    public void basics() {
+        Set<TestVertex> vertexes = ImmutableSet.of(A, B, C, D, E, F);
+        AdjacencyListsGraph<TestVertex, TestEdge> graph = new AdjacencyListsGraph<>(vertexes, edges);
+        assertEquals("incorrect vertex count", 6, graph.getVertexes().size());
+        assertEquals("incorrect edge count", 5, graph.getEdges().size());
+
+        assertEquals("incorrect egress edge count", 1, graph.getEdgesFrom(A).size());
+        assertEquals("incorrect ingress edge count", 1, graph.getEdgesTo(A).size());
+        assertEquals("incorrect ingress edge count", 1, graph.getEdgesTo(C).size());
+        assertEquals("incorrect egress edge count", 2, graph.getEdgesFrom(B).size());
+        assertEquals("incorrect ingress edge count", 2, graph.getEdgesTo(D).size());
+    }
 }
 }

@@ -7,27 +7,28 @@ import java.util.Set;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertEquals;
 
 
 /**
 /**
- * Test of the BFS algorithm.
+ * Test of the BFS and similar path search algorithms.
  */
  */
-public abstract class BreadthFirstSearchTest extends AbstractGraphSearchTest {
+public class BreadthFirstSearchTest extends AbstractGraphPathSearchTest {
 
 
     @Override
     @Override
-    protected GraphPathSearch<TestVertex, TestEdge> graphSearch() {
-        return null; // new BreadthFirstSearch();
+    protected AbstractGraphPathSearch<TestVertex, TestEdge> graphSearch() {
+        return new BreadthFirstSearch<>();
     }
     }
 
 
     @Test
     @Test
-    public void basics() {
-        runBasics(3, 8.0, 7);
+    public void defaultGraphTest() {
+        executeDefaultTest(7, 3, 8.0);
     }
     }
 
 
     @Test
     @Test
-    public void defaultWeight() {
+    public void defaultHopCountWeight() {
         weight = null;
         weight = null;
-        runBasics(3, 3.0, 7);
+        executeDefaultTest(7, 3, 3.0);
     }
     }
 
 
-    protected void runBasics(int expectedLength, double expectedCost, int expectedPaths) {
+    // Executes the default test
+    protected void executeDefaultTest(int pathCount, int pathLength, double pathCost) {
         g = new AdjacencyListsGraph<>(vertices(), edges());
         g = new AdjacencyListsGraph<>(vertices(), edges());
 
 
         GraphPathSearch<TestVertex, TestEdge> search = graphSearch();
         GraphPathSearch<TestVertex, TestEdge> search = graphSearch();
@@ -37,12 +38,29 @@ public abstract class BreadthFirstSearchTest extends AbstractGraphSearchTest {
         Path p = paths.iterator().next();
         Path p = paths.iterator().next();
         assertEquals("incorrect src", A, p.src());
         assertEquals("incorrect src", A, p.src());
         assertEquals("incorrect dst", H, p.dst());
         assertEquals("incorrect dst", H, p.dst());
-        assertEquals("incorrect path length", expectedLength, p.edges().size());
-        assertEquals("incorrect path cost", expectedCost, p.cost(), 0.1);
+        assertEquals("incorrect path length", pathLength, p.edges().size());
+        assertEquals("incorrect path cost", pathCost, p.cost(), 0.1);
 
 
         paths = search.search(g, A, null, weight).paths();
         paths = search.search(g, A, null, weight).paths();
         printPaths(paths);
         printPaths(paths);
-        assertEquals("incorrect paths count", expectedPaths, paths.size());
+        assertEquals("incorrect paths count", pathCount, paths.size());
+    }
+
+    // Executes the search and validates its results.
+    protected void executeSearch(GraphPathSearch<TestVertex, TestEdge> search,
+                                 Graph<TestVertex, TestEdge> graph,
+                                 TestVertex src, TestVertex dst,
+                                 EdgeWeight<TestVertex, TestEdge> weight,
+                                 int pathCount, double pathCost) {
+        GraphPathSearch.Result<TestVertex, TestEdge> result =
+                search.search(graph, src, dst, weight);
+        Set<Path<TestVertex, TestEdge>> paths = result.paths();
+        printPaths(paths);
+        assertEquals("incorrect paths count", pathCount, paths.size());
+        if (pathCount > 0) {
+            Path<TestVertex, TestEdge> path = paths.iterator().next();
+            assertEquals("incorrect path cost", pathCost, path.cost(), 0.1);
+        }
     }
     }
 
 
 }
 }

+package org.onlab.graph;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.testing.EqualsTester;
+import org.junit.Test;
+
+import java.util.Iterator;
+import java.util.List;
+
+import static com.google.common.collect.ImmutableList.of;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+/**
+ * Test of the default mutable path.
+ */
+public class DefaultMutablePathTest extends DefaultPathTest {
+
+    @Test
+    public void equality() {
+        DefaultPath<TestVertex, TestEdge> p1 =
+                new DefaultPath<>(of(new TestEdge(A, B, 1),
+                                     new TestEdge(B, C, 1)), 2.0);
+        DefaultPath<TestVertex, TestEdge> p2 =
+                new DefaultPath<>(of(new TestEdge(A, B, 1),
+                                     new TestEdge(B, D, 1)), 2.0);
+        new EqualsTester().addEqualityGroup(new DefaultMutablePath<>(p1),
+                                            new DefaultMutablePath<>(p1))
+                .addEqualityGroup(new DefaultMutablePath<>(p2))
+                .testEquals();
+    }
+
+    @Test
+    public void empty() {
+        MutablePath<TestVertex, TestEdge> p = new DefaultMutablePath<>();
+        assertNull("src should be null", p.src());
+        assertNull("dst should be null", p.dst());
+        assertEquals("incorrect edge count", 0, p.edges().size());
+        assertEquals("incorrect path cost", 0.0, p.cost(), 0.1);
+    }
+
+    @Test
+    public void pathCost() {
+        MutablePath<TestVertex, TestEdge> p = new DefaultMutablePath<>();
+        p.setCost(4);
+        assertEquals("incorrect path cost", 4.0, p.cost(), 0.1);
+    }
+
+    private void validatePath(Path<TestVertex, TestEdge> p,
+                              TestVertex src, TestVertex dst, int length) {
+        validatePath(p, src, dst, length, 0.0);
+    }
+
+    @Test
+    public void insertEdge() {
+        MutablePath<TestVertex, TestEdge> p = new DefaultMutablePath<>();
+        p.insertEdge(new TestEdge(B, C, 1));
+        p.insertEdge(new TestEdge(A, B, 1));
+        validatePath(p, A, C, 2);
+    }
+
+    @Test
+    public void appendEdge() {
+        MutablePath<TestVertex, TestEdge> p = new DefaultMutablePath<>();
+        p.appendEdge(new TestEdge(A, B, 1));
+        p.appendEdge(new TestEdge(B, C, 1));
+        validatePath(p, A, C, 2);
+    }
+
+    @Test
+    public void removeEdge() {
+        MutablePath<TestVertex, TestEdge> p = new DefaultMutablePath<>();
+        p.appendEdge(new TestEdge(A, B, 1));
+        p.appendEdge(new TestEdge(B, C, 1));
+        p.appendEdge(new TestEdge(C, C, 2));
+        p.appendEdge(new TestEdge(C, D, 1));
+        validatePath(p, A, D, 4);
+
+        p.removeEdge(new TestEdge(A, B, 1));
+        validatePath(p, B, D, 3);
+
+        p.removeEdge(new TestEdge(C, C, 2));
+        validatePath(p, B, D, 2);
+
+        p.removeEdge(new TestEdge(C, D, 1));
+        validatePath(p, B, C, 1);
+    }
+
+    @Test
+    public void toImmutable() {
+        MutablePath<TestVertex, TestEdge> p = new DefaultMutablePath<>();
+        p.appendEdge(new TestEdge(A, B, 1));
+        p.appendEdge(new TestEdge(B, C, 1));
+        validatePath(p, A, C, 2);
+
+        assertEquals("immutables should equal", p.toImmutable(), p.toImmutable());
+        validatePath(p.toImmutable(), A, C, 2);
+    }
+}

+package org.onlab.graph;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.testing.EqualsTester;
+import org.junit.Test;
+
+import java.util.List;
+
+import static com.google.common.collect.ImmutableList.of;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+/**
+ * Test of the default path.
+ */
+public class DefaultPathTest extends GraphTest {
+
+    @Test
+    public void equality() {
+        List<TestEdge> edges = of(new TestEdge(A, B, 1), new TestEdge(B, C, 1));
+        new EqualsTester().addEqualityGroup(new DefaultPath<>(edges, 2.0),
+                                            new DefaultPath<>(edges, 2.0))
+                .addEqualityGroup(new DefaultPath<>(edges, 3.0))
+                .testEquals();
+    }
+
+    @Test
+    public void basics() {
+        Path<TestVertex, TestEdge> p = new DefaultPath<>(of(new TestEdge(A, B, 1),
+                                                            new TestEdge(B, C, 1)), 2.0);
+        validatePath(p, A, C, 2, 2.0);
+    }
+
+    // Validates the path against expected attributes
+    protected void validatePath(Path<TestVertex, TestEdge> p,
+                              TestVertex src, TestVertex dst,
+                              int length, double cost) {
+        assertEquals("incorrect path length", length, p.edges().size());
+        assertEquals("incorrect source", src, p.src());
+        assertEquals("incorrect destination", dst, p.dst());
+        assertEquals("incorrect path cost", cost, p.cost(), 0.1);
+    }
+
+}

 package org.onlab.graph;
 package org.onlab.graph;
 
 
-import com.google.common.collect.ImmutableSet;
 import org.junit.Test;
 import org.junit.Test;
 
 
 import java.util.Set;
 import java.util.Set;
 
 
+import static com.google.common.collect.ImmutableSet.of;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertEquals;
 
 
 /**
 /**
@@ -13,30 +13,30 @@ import static org.junit.Assert.assertEquals;
 public class DijkstraGraphSearchTest extends BreadthFirstSearchTest {
 public class DijkstraGraphSearchTest extends BreadthFirstSearchTest {
 
 
     @Override
     @Override
-    protected GraphPathSearch<TestVertex, TestEdge> graphSearch() {
+    protected AbstractGraphPathSearch<TestVertex, TestEdge> graphSearch() {
         return new DijkstraGraphSearch<>();
         return new DijkstraGraphSearch<>();
     }
     }
 
 
     @Test
     @Test
     @Override
     @Override
-    public void basics() {
-        runBasics(5, 5.0, 7);
+    public void defaultGraphTest() {
+        executeDefaultTest(7, 5, 5.0);
     }
     }
 
 
     @Test
     @Test
-    public void defaultWeight() {
+    @Override
+    public void defaultHopCountWeight() {
         weight = null;
         weight = null;
-        runBasics(3, 3.0, 10);
+        executeDefaultTest(10, 3, 3.0);
     }
     }
 
 
     @Test
     @Test
     public void noPath() {
     public void noPath() {
-        g = new AdjacencyListsGraph<>(ImmutableSet.of(A, B, C, D),
-                                      ImmutableSet.of(new TestEdge(A, B, 1),
+        g = new AdjacencyListsGraph<>(of(A, B, C, D),
+                                      of(new TestEdge(A, B, 1),
                                          new TestEdge(B, A, 1),
                                          new TestEdge(B, A, 1),
                                          new TestEdge(C, D, 1),
                                          new TestEdge(C, D, 1),
                                          new TestEdge(D, C, 1)));
                                          new TestEdge(D, C, 1)));
-
         GraphPathSearch<TestVertex, TestEdge> gs = graphSearch();
         GraphPathSearch<TestVertex, TestEdge> gs = graphSearch();
         Set<Path<TestVertex, TestEdge>> paths = gs.search(g, A, B, weight).paths();
         Set<Path<TestVertex, TestEdge>> paths = gs.search(g, A, B, weight).paths();
         printPaths(paths);
         printPaths(paths);
@@ -54,24 +54,19 @@ public class DijkstraGraphSearchTest extends BreadthFirstSearchTest {
     }
     }
 
 
     @Test
     @Test
-    public void multiPath1() {
-        g = new AdjacencyListsGraph<>(ImmutableSet.of(A, B, C, D),
-                                      ImmutableSet.of(new TestEdge(A, B, 1),
+    public void simpleMultiplePath() {
+        g = new AdjacencyListsGraph<>(of(A, B, C, D),
+                                      of(new TestEdge(A, B, 1),
                                          new TestEdge(A, C, 1),
                                          new TestEdge(A, C, 1),
                                          new TestEdge(B, D, 1),
                                          new TestEdge(B, D, 1),
                                          new TestEdge(C, D, 1)));
                                          new TestEdge(C, D, 1)));
-
-        GraphPathSearch<TestVertex, TestEdge> gs = graphSearch();
-        Set<Path<TestVertex, TestEdge>> paths = gs.search(g, A, D, weight).paths();
-        printPaths(paths);
-        assertEquals("incorrect paths count", 2, paths.size());
-        assertEquals("incorrect path cost", 2.0, paths.iterator().next().cost(), 0.1);
+        executeSearch(graphSearch(), g, A, D, weight, 2, 2.0);
     }
     }
 
 
     @Test
     @Test
-    public void multiPath2() {
-        g = new AdjacencyListsGraph<>(ImmutableSet.of(A, B, C, D, E, F, G),
-                                      ImmutableSet.of(new TestEdge(A, B, 1),
+    public void denseMultiplePath() {
+        g = new AdjacencyListsGraph<>(of(A, B, C, D, E, F, G),
+                                      of(new TestEdge(A, B, 1),
                                          new TestEdge(A, C, 1),
                                          new TestEdge(A, C, 1),
                                          new TestEdge(B, D, 1),
                                          new TestEdge(B, D, 1),
                                          new TestEdge(C, D, 1),
                                          new TestEdge(C, D, 1),
@@ -80,31 +75,20 @@ public class DijkstraGraphSearchTest extends BreadthFirstSearchTest {
                                          new TestEdge(E, G, 1),
                                          new TestEdge(E, G, 1),
                                          new TestEdge(F, G, 1),
                                          new TestEdge(F, G, 1),
                                          new TestEdge(A, G, 4)));
                                          new TestEdge(A, G, 4)));
-
-        GraphPathSearch<TestVertex, TestEdge> gs = graphSearch();
-        GraphPathSearch.Result<TestVertex, TestEdge> gsr = gs.search(g, A, G, weight);
-        Set<Path<TestVertex, TestEdge>> paths = gsr.paths();
-        printPaths(paths);
-        assertEquals("incorrect paths count", 5, paths.size());
-        assertEquals("incorrect path cost", 4.0, paths.iterator().next().cost(), 0.1);
+        executeSearch(graphSearch(), g, A, G, weight, 5, 4.0);
     }
     }
 
 
     @Test
     @Test
-    public void multiPath3() {
-        g = new AdjacencyListsGraph<>(ImmutableSet.of(A, B, C, D, E, F, G, H),
-                                      ImmutableSet.of(new TestEdge(A, B, 1), new TestEdge(A, C, 3),
+    public void dualEdgeMultiplePath() {
+        g = new AdjacencyListsGraph<>(of(A, B, C, D, E, F, G, H),
+                                      of(new TestEdge(A, B, 1), new TestEdge(A, C, 3),
                                          new TestEdge(B, D, 2), new TestEdge(B, C, 1),
                                          new TestEdge(B, D, 2), new TestEdge(B, C, 1),
                                          new TestEdge(B, E, 4), new TestEdge(C, E, 1),
                                          new TestEdge(B, E, 4), new TestEdge(C, E, 1),
                                          new TestEdge(D, H, 5), new TestEdge(D, E, 1),
                                          new TestEdge(D, H, 5), new TestEdge(D, E, 1),
                                          new TestEdge(E, F, 1), new TestEdge(F, D, 1),
                                          new TestEdge(E, F, 1), new TestEdge(F, D, 1),
                                          new TestEdge(F, G, 1), new TestEdge(F, H, 1),
                                          new TestEdge(F, G, 1), new TestEdge(F, H, 1),
                                          new TestEdge(A, E, 3), new TestEdge(B, D, 1)));
                                          new TestEdge(A, E, 3), new TestEdge(B, D, 1)));
-
-        GraphPathSearch<TestVertex, TestEdge> gs = graphSearch();
-        Set<Path<TestVertex, TestEdge>> paths = gs.search(g, A, E, weight).paths();
-        printPaths(paths);
-        assertEquals("incorrect paths count", 3, paths.size());
-        assertEquals("incorrect path cost", 3.0, paths.iterator().next().cost(), 0.1);
+        executeSearch(graphSearch(), g, A, E, weight, 3, 3.0);
     }
     }
 
 
 }
 }

@@ -4,6 +4,8 @@ import com.google.common.collect.ImmutableSet;
 
 
 import java.util.Set;
 import java.util.Set;
 
 
+import static com.google.common.collect.ImmutableSet.of;
+
 /**
 /**
  * Base class for various graph-related tests.
  * Base class for various graph-related tests.
  */
  */
@@ -35,11 +37,11 @@ public class GraphTest {
     }
     }
 
 
     protected Set<TestVertex> vertices() {
     protected Set<TestVertex> vertices() {
-        return ImmutableSet.of(A, B, C, D, E, F, G, H);
+        return of(A, B, C, D, E, F, G, H);
     }
     }
 
 
     protected Set<TestEdge> edges() {
     protected Set<TestEdge> edges() {
-        return ImmutableSet.of(new TestEdge(A, B, 1), new TestEdge(A, C, 3),
+        return of(new TestEdge(A, B, 1), new TestEdge(A, C, 3),
                   new TestEdge(B, D, 2), new TestEdge(B, C, 1),
                   new TestEdge(B, D, 2), new TestEdge(B, C, 1),
                   new TestEdge(B, E, 4), new TestEdge(C, E, 1),
                   new TestEdge(B, E, 4), new TestEdge(C, E, 1),
                   new TestEdge(D, H, 5), new TestEdge(D, E, 1),
                   new TestEdge(D, H, 5), new TestEdge(D, E, 1),

@@ -9,6 +9,7 @@ import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.Iterator;
 
 
+import static com.google.common.collect.ImmutableList.of;
 import static org.junit.Assert.*;
 import static org.junit.Assert.*;
 
 
 /**
 /**
@@ -17,25 +18,42 @@ import static org.junit.Assert.*;
 public class HeapTest {
 public class HeapTest {
 
 
     private ArrayList<Integer> data =
     private ArrayList<Integer> data =
-            new ArrayList<>(ImmutableList.of(6, 4, 5, 9, 8, 3, 2, 1, 7, 0));
+            new ArrayList<>(of(6, 4, 5, 9, 8, 3, 2, 1, 7, 0));
 
 
-    private static final Comparator<Integer> ASCENDING = Ordering.natural().reverse();
-    private static final Comparator<Integer> DESCENDING = Ordering.natural();
+    private static final Comparator<Integer> MIN = Ordering.natural().reverse();
+    private static final Comparator<Integer> MAX = Ordering.natural();
 
 
     @Test
     @Test
     public void equality() {
     public void equality() {
         new EqualsTester()
         new EqualsTester()
-                .addEqualityGroup(new Heap<>(data, ASCENDING),
-                                  new Heap<>(data, ASCENDING))
-                .addEqualityGroup(new Heap<>(data, DESCENDING))
+                .addEqualityGroup(new Heap<>(data, MIN),
+                                  new Heap<>(data, MIN))
+                .addEqualityGroup(new Heap<>(data, MAX))
                 .testEquals();
                 .testEquals();
     }
     }
 
 
     @Test
     @Test
-    public void ascending() {
-        Heap<Integer> h = new Heap<>(data, ASCENDING);
+    public void empty() {
+        Heap<Integer> h = new Heap<>(new ArrayList<Integer>(), MIN);
+        assertTrue("should be empty", h.isEmpty());
+        assertEquals("incorrect size", 0, h.size());
+        assertNull("no item expected", h.extreme());
+        assertNull("no item expected", h.extractExtreme());
+    }
+
+    @Test
+    public void insert() {
+        Heap<Integer> h = new Heap<>(data, MIN);
         assertEquals("incorrect size", 10, h.size());
         assertEquals("incorrect size", 10, h.size());
+        h.insert(3);
+        assertEquals("incorrect size", 11, h.size());
+    }
+
+    @Test
+    public void minQueue() {
+        Heap<Integer> h = new Heap<>(data, MIN);
         assertFalse("should not be empty", h.isEmpty());
         assertFalse("should not be empty", h.isEmpty());
+        assertEquals("incorrect size", 10, h.size());
         assertEquals("incorrect extreme", (Integer) 0, h.extreme());
         assertEquals("incorrect extreme", (Integer) 0, h.extreme());
 
 
         for (int i = 0, n = h.size(); i < n; i++) {
         for (int i = 0, n = h.size(); i < n; i++) {
@@ -45,10 +63,10 @@ public class HeapTest {
     }
     }
 
 
     @Test
     @Test
-    public void descending() {
-        Heap<Integer> h = new Heap<>(data, DESCENDING);
-        assertEquals("incorrect size", 10, h.size());
+    public void maxQueue() {
+        Heap<Integer> h = new Heap<>(data, MAX);
         assertFalse("should not be empty", h.isEmpty());
         assertFalse("should not be empty", h.isEmpty());
+        assertEquals("incorrect size", 10, h.size());
         assertEquals("incorrect extreme", (Integer) 9, h.extreme());
         assertEquals("incorrect extreme", (Integer) 9, h.extreme());
 
 
         for (int i = h.size(); i > 0; i--) {
         for (int i = h.size(); i > 0; i--) {
@@ -58,29 +76,9 @@ public class HeapTest {
     }
     }
 
 
     @Test
     @Test
-    public void empty() {
-        Heap<Integer> h = new Heap<>(new ArrayList<Integer>(), ASCENDING);
-        assertEquals("incorrect size", 0, h.size());
-        assertTrue("should be empty", h.isEmpty());
-        assertNull("no item expected", h.extreme());
-        assertNull("no item expected", h.extractExtreme());
-    }
-
-    @Test
-    public void insert() {
-        Heap<Integer> h = new Heap<>(data, ASCENDING);
-        assertEquals("incorrect size", 10, h.size());
-        h.insert(3);
-        assertEquals("incorrect size", 11, h.size());
-    }
-
-    @Test
     public void iterator() {
     public void iterator() {
-        Heap<Integer> h = new Heap<>(data, ASCENDING);
-        Iterator<Integer> it = h.iterator();
-        while (it.hasNext()) {
-            int item = it.next();
-        }
+        Heap<Integer> h = new Heap<>(data, MIN);
+        assertTrue("should have next element", h.iterator().hasNext());
     }
     }
 
 
 }
 }

@@ -2,6 +2,8 @@ package org.onlab.graph;
 
 
 import java.util.Objects;
 import java.util.Objects;
 
 
+import static com.google.common.base.Objects.toStringHelper;
+
 /**
 /**
  * Test edge.
  * Test edge.
  */
  */
@@ -43,4 +45,11 @@ public class TestEdge extends AbstractEdge<TestVertex> {
         }
         }
         return false;
         return false;
     }
     }
+
+    @Override
+    public String toString() {
+        return toStringHelper(this).add("src", src()).add("dst", dst()).
+                add("weight", weight).toString();
+    }
+
 }
 }

@@ -16,11 +16,6 @@ public class TestVertex implements Vertex {
     }
     }
 
 
     @Override
     @Override
-    public String toString() {
-        return toStringHelper(this).add("name", name).toString();
-    }
-
-    @Override
     public int hashCode() {
     public int hashCode() {
         return Objects.hash(name);
         return Objects.hash(name);
     }
     }
@@ -34,4 +29,9 @@ public class TestVertex implements Vertex {
         return false;
         return false;
     }
     }
 
 
+    @Override
+    public String toString() {
+        return name;
+    }
+
 }
 }