diff --git a/utils/misc/src/test/java/org/onlab/graph/DijkstraGraphSearchTest.java b/utils/misc/src/test/java/org/onlab/graph/DijkstraGraphSearchTest.java
index 5ee4caa..1731440 100644
--- a/utils/misc/src/test/java/org/onlab/graph/DijkstraGraphSearchTest.java
+++ b/utils/misc/src/test/java/org/onlab/graph/DijkstraGraphSearchTest.java
@@ -1,10 +1,10 @@
 package org.onlab.graph;
 
-import com.google.common.collect.ImmutableSet;
 import org.junit.Test;
 
 import java.util.Set;
 
+import static com.google.common.collect.ImmutableSet.of;
 import static org.junit.Assert.assertEquals;
 
 /**
@@ -13,30 +13,30 @@
 public class DijkstraGraphSearchTest extends BreadthFirstSearchTest {
 
     @Override
-    protected GraphPathSearch<TestVertex, TestEdge> graphSearch() {
+    protected AbstractGraphPathSearch<TestVertex, TestEdge> graphSearch() {
         return new DijkstraGraphSearch<>();
     }
 
     @Test
     @Override
-    public void basics() {
-        runBasics(5, 5.0, 7);
+    public void defaultGraphTest() {
+        executeDefaultTest(7, 5, 5.0);
     }
 
     @Test
-    public void defaultWeight() {
+    @Override
+    public void defaultHopCountWeight() {
         weight = null;
-        runBasics(3, 3.0, 10);
+        executeDefaultTest(10, 3, 3.0);
     }
 
     @Test
     public void noPath() {
-        g = new AdjacencyListsGraph<>(ImmutableSet.of(A, B, C, D),
-                                      ImmutableSet.of(new TestEdge(A, B, 1),
-                                                      new TestEdge(B, A, 1),
-                                                      new TestEdge(C, D, 1),
-                                                      new TestEdge(D, C, 1)));
-
+        g = new AdjacencyListsGraph<>(of(A, B, C, D),
+                                      of(new TestEdge(A, B, 1),
+                                         new TestEdge(B, A, 1),
+                                         new TestEdge(C, D, 1),
+                                         new TestEdge(D, C, 1)));
         GraphPathSearch<TestVertex, TestEdge> gs = graphSearch();
         Set<Path<TestVertex, TestEdge>> paths = gs.search(g, A, B, weight).paths();
         printPaths(paths);
@@ -54,57 +54,41 @@
     }
 
     @Test
-    public void multiPath1() {
-        g = new AdjacencyListsGraph<>(ImmutableSet.of(A, B, C, D),
-                                      ImmutableSet.of(new TestEdge(A, B, 1),
-                                                      new TestEdge(A, C, 1),
-                                                      new TestEdge(B, 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);
+    public void simpleMultiplePath() {
+        g = new AdjacencyListsGraph<>(of(A, B, C, D),
+                                      of(new TestEdge(A, B, 1),
+                                         new TestEdge(A, C, 1),
+                                         new TestEdge(B, D, 1),
+                                         new TestEdge(C, D, 1)));
+        executeSearch(graphSearch(), g, A, D, weight, 2, 2.0);
     }
 
     @Test
-    public void multiPath2() {
-        g = new AdjacencyListsGraph<>(ImmutableSet.of(A, B, C, D, E, F, G),
-                                      ImmutableSet.of(new TestEdge(A, B, 1),
-                                                      new TestEdge(A, C, 1),
-                                                      new TestEdge(B, D, 1),
-                                                      new TestEdge(C, D, 1),
-                                                      new TestEdge(D, E, 1),
-                                                      new TestEdge(D, F, 1),
-                                                      new TestEdge(E, G, 1),
-                                                      new TestEdge(F, G, 1),
-                                                      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);
+    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(B, D, 1),
+                                         new TestEdge(C, D, 1),
+                                         new TestEdge(D, E, 1),
+                                         new TestEdge(D, F, 1),
+                                         new TestEdge(E, G, 1),
+                                         new TestEdge(F, G, 1),
+                                         new TestEdge(A, G, 4)));
+        executeSearch(graphSearch(), g, A, G, weight, 5, 4.0);
     }
 
     @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),
-                                                      new TestEdge(B, D, 2), new TestEdge(B, C, 1),
-                                                      new TestEdge(B, E, 4), new TestEdge(C, E, 1),
-                                                      new TestEdge(D, H, 5), new TestEdge(D, E, 1),
-                                                      new TestEdge(E, F, 1), new TestEdge(F, D, 1),
-                                                      new TestEdge(F, G, 1), new TestEdge(F, H, 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);
+    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, E, 4), new TestEdge(C, E, 1),
+                                         new TestEdge(D, H, 5), new TestEdge(D, E, 1),
+                                         new TestEdge(E, F, 1), new TestEdge(F, D, 1),
+                                         new TestEdge(F, G, 1), new TestEdge(F, H, 1),
+                                         new TestEdge(A, E, 3), new TestEdge(B, D, 1)));
+        executeSearch(graphSearch(), g, A, E, weight, 3, 3.0);
     }
 
 }