This is probably the stupidest implementation ever, but it works. To be fixed!

tests/unit_dag.cpp

@@ -1,7 +1,6 @@
 #include <iostream>
 
 #include "daggy/DAG.hpp"
-#include "daggy/DAGVisitor.hpp"
 
 #include "catch.hpp"
 
@@ -17,27 +16,69 @@ TEST_CASE("DAG Construction Tests", "[dag]") {
       dag.addEdge(i-1, i);
     }
 
-    REQUIRE(dag.getRoots().size() == 1);
     REQUIRE(dag.size() == 10);
     REQUIRE(! dag.empty());
 
     // Cannot add an edge that would result in a cycle
     REQUIRE_THROWS(dag.addEdge(9, 5));
+
+    SECTION("Visit State") {
+      dag.setVisitState(daggy::VertexState::VISITING);
+      for (const auto v : dag.getVertices()) {
+        REQUIRE(dag.getVertexState(v) == daggy::VertexState::VISITING);
+      }
+    }
 }
 
-TEST_CASE("DAG Basic Tests", "[dag]") {
+TEST_CASE("DAG Traversal Tests", "[dag]") {
     daggy::DAG<int> dag;
 
-    dag.addVertex(0);
-    for (int i = 1; i < 10; ++i) {
-      dag.addVertex(i);
-      dag.addEdge(i-1, i);
+    const int N_VERTICES = 10;
+
+    for (int i = 0; i < N_VERTICES; ++i) { dag.addVertex(i); }
+
+    /*
+       0 ---------------------\
+       1 ---------- \          \
+       2 ---- 3 ---- > 5 -------> 6 -----> 7
+       4 -------------------------------/
+       8 --> 9
+    */
+
+    std::vector<std::pair<int,int>> edges{
+      {0, 6}
+      , {1, 5}
+      , {5, 6}
+      , {6, 7}
+      , {2, 3}
+      , {3, 5}
+      , {4, 7}
+      , {8, 9}
+    };
+
+    for (auto const [from, to] : edges) {
+      dag.addEdge(from, to);
     }
 
-    SECTION("Pathing") {
-      REQUIRE(dag.shortestPath(0,9).size() == 10);
+    SECTION("Baisc Traversal") {
+      dag.setVisitState(daggy::VertexState::UNVISITED);
+      std::vector<int> visitOrder(N_VERTICES);
+      size_t i = 0;
+      while (! dag.allVisited()) {
+        const auto & v = dag.visitNext().value();
+        dag.completeVisit(v);
+        visitOrder[v] = i;
+        ++i;
+      }
 
-      dag.addEdge(5, 9);
-      REQUIRE(dag.shortestPath(0,9).size() == 7);
+      std::cout << "ORDER:";
+      for (size_t i = 0; i < N_VERTICES; ++i) std::cout << " (" << i << ',' << visitOrder[i] << ')';
+      //for (auto v : visitOrder) std::cout << " " << v;
+      std::cout << std::endl;
+
+      // Ensure visit order is preserved
+      for (auto const [from, to] : edges) {
+        REQUIRE(visitOrder[from] <= visitOrder[to]);
+      }
     }
 }