diff --git a/utils/misc/src/test/java/org/onlab/graph/BreadthFirstSearchTest.java b/utils/misc/src/test/java/org/onlab/graph/BreadthFirstSearchTest.java
index ae45750..f9c752d 100644
--- a/utils/misc/src/test/java/org/onlab/graph/BreadthFirstSearchTest.java
+++ b/utils/misc/src/test/java/org/onlab/graph/BreadthFirstSearchTest.java
@@ -7,27 +7,28 @@
 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
-    protected GraphPathSearch<TestVertex, TestEdge> graphSearch() {
-        return null; // new BreadthFirstSearch();
+    protected AbstractGraphPathSearch<TestVertex, TestEdge> graphSearch() {
+        return new BreadthFirstSearch<>();
     }
 
     @Test
-    public void basics() {
-        runBasics(3, 8.0, 7);
+    public void defaultGraphTest() {
+        executeDefaultTest(7, 3, 8.0);
     }
 
     @Test
-    public void defaultWeight() {
+    public void defaultHopCountWeight() {
         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());
 
         GraphPathSearch<TestVertex, TestEdge> search = graphSearch();
@@ -37,12 +38,29 @@
         Path p = paths.iterator().next();
         assertEquals("incorrect src", A, p.src());
         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();
         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);
+        }
     }
 
 }