Add algorithm unit tests and fix prim.hpp bugs

New test files:
- betweenness_centrality_test.cpp: Brandes BC algorithm tests
- delta_stepping_test.cpp: Delta-stepping SSSP tests
- jaccard_test.cpp: Jaccard similarity tests
- prim_test.cpp: Prim's MST algorithm tests

Bug fixes in prim.hpp:
- Add missing Q.push({source, 0}) to initialize priority queue
- Add missing finished[u] = true after popping from queue
- Fix variable name g[u] -> graph[u]
- Fix predecessor vector type from Distance to vertex_id_type

Test coverage improved from 171 to 189 tests (all passing).
Algorithm coverage: 16/18 headers tested (89%).

🤖 Generated with Claude Code

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: lums658

agents/nwgraph_test_spec.md

@@ -70,11 +70,11 @@ This section maps every header file to its corresponding test(s).
 
 | Header | Test File | Status |
 |--------|-----------|--------|
-| `betweenness_centrality.hpp` | `bk_test.cpp` | ❌ Disabled |
+| `betweenness_centrality.hpp` | `betweenness_centrality_test.cpp` | ✅ Active |
 | `bfs.hpp` | `bfs_test_0.cpp`, `bfs_test_1.cpp` | ✅ Active |
 | `boykov_kolmogorov.hpp` | `max_flow_test.cpp` | ❌ Disabled |
 | `connected_components.hpp` | `connected_component_test.cpp` | ✅ Active |
-| `dag_based_mis.hpp` | `dag_mis_test.cpp` | ✅ Active |
+| `dag_based_mis.hpp` | `mis_test.cpp` | ✅ Active |
 | `delta_stepping.hpp` | `delta_stepping_test.cpp` | ✅ Active |
 | `dijkstra.hpp` | `dijkstra_test.cpp` | ✅ Active |
 | `jaccard.hpp` | `jaccard_test.cpp` | ✅ Active |
@@ -85,7 +85,7 @@ This section maps every header file to its corresponding test(s).
 | `max_flow.hpp` | `max_flow_test.cpp` | ❌ Disabled |
 | `maximal_independent_set.hpp` | `mis_test.cpp` | ✅ Active |
 | `page_rank.hpp` | `page_rank_test.cpp` | ✅ Active |
-| `prim.hpp` | - | ❌ Header has bugs |
+| `prim.hpp` | `prim_test.cpp` | ✅ Active |
 | `spMatspMat.hpp` | `spMatspMat_test.cpp` | ✅ Active |
 | `triangle_count.hpp` | `tc_test.cpp` | ✅ Active |
 
@@ -168,10 +168,10 @@ Experimental parallel implementations - not unit tested as they mirror main algo
 - `size_test`
 
 ### Algorithm Tests
+- `betweenness_centrality_test`
 - `bfs_test_0`
 - `bfs_test_1`
 - `connected_component_test`
-- `dag_mis_test`
 - `delta_stepping_test`
 - `dijkstra_test`
 - `jaccard_test`
@@ -180,6 +180,7 @@ Experimental parallel implementations - not unit tested as they mirror main algo
 - `mis_test`
 - `new_dfs_test`
 - `page_rank_test`
+- `prim_test`
 - `spanning_tree_test`
 - `spMatspMat_test`
 - `tc_test`
@@ -281,14 +282,15 @@ In-memory karate graph for quick tests without file I/O.
 |----------|---------------|--------|----------|
 | Adaptors | 17 | 14 | 82% |
 | Core | 13 | 13 | 100% |
-| Algorithms | 18 | 14 | 78% |
+| Algorithms | 18 | 16 | 89% |
 | Containers | 4 | 4 | 100% |
 | Graphs | 3 | 3 | 100% |
 | I/O | 2 | 2 | 100% |
 | Utilities | 18 | 15 | 83% |
-| **Total** | **75** | **65** | **87%** |
+| **Total** | **75** | **67** | **89%** |
 
 Note: Some headers are not tested due to:
 - TBB-specific functionality (requires TBB for testing)
 - Broken headers (syntax errors or bugs)
 - Type definitions only (no testable behavior)
+- Empty/stub implementations (k_truss.hpp)

include/nwgraph/algorithms/prim.hpp

@@ -43,8 +43,8 @@ std::vector<vertex_id_t<Graph>> prim(const Graph& graph, vertex_id_t<Graph> sour
   size_t N { num_vertices(graph) };
   assert(source < N);
 
-  std::vector<Distance> distance(N, std::numeric_limits<Distance>::max());
-  std::vector<Distance> predecessor(N, std::numeric_limits<Distance>::max());
+  std::vector<Distance>       distance(N, std::numeric_limits<Distance>::max());
+  std::vector<vertex_id_type> predecessor(N, std::numeric_limits<vertex_id_type>::max());
   std::vector<uint8_t>  finished(N, false);
   distance[source] = 0;
 
@@ -53,6 +53,8 @@ std::vector<vertex_id_t<Graph>> prim(const Graph& graph, vertex_id_t<Graph> sour
 
   std::priority_queue<weighted_vertex, std::vector<weighted_vertex>, std::greater<weighted_vertex>> Q;
 
+  Q.push({source, 0});
+
   while (!Q.empty()) {
 
     auto u = std::get<0>(Q.top());
@@ -61,8 +63,9 @@ std::vector<vertex_id_t<Graph>> prim(const Graph& graph, vertex_id_t<Graph> sour
     if (finished[u]) {
       continue;
     }
+    finished[u] = true;
 
-    std::for_each(g[u].begin(), g[u].end(), [&](auto&& e) {
+    std::for_each(graph[u].begin(), graph[u].end(), [&](auto&& e) {
       auto v = target(graph, e);
       auto w = weight(e);
 

test/CMakeLists.txt

@@ -47,15 +47,19 @@ nwgraph_add_test(size_test)
 # -----------------------------------------------------------------------------
 # Algorithm Tests
 # -----------------------------------------------------------------------------
+nwgraph_add_test(betweenness_centrality_test)
 nwgraph_add_test(bfs_test_0)
 nwgraph_add_test(bfs_test_1)
 nwgraph_add_test(connected_component_test)
+nwgraph_add_test(delta_stepping_test)
 nwgraph_add_test(dijkstra_test)
+nwgraph_add_test(jaccard_test)
 nwgraph_add_test(jp_coloring_test)
 nwgraph_add_test(kruskal_test)
 nwgraph_add_test(mis_test)
 nwgraph_add_test(new_dfs_test)
 nwgraph_add_test(page_rank_test)
+nwgraph_add_test(prim_test)
 nwgraph_add_test(spanning_tree_test)
 nwgraph_add_test(spMatspMat_test)
 nwgraph_add_test(tc_test)

test/betweenness_centrality_test.cpp

@@ -0,0 +1,187 @@
+/**
+ * @file betweenness_centrality_test.cpp
+ *
+ * @copyright SPDX-FileCopyrightText: 2022 Battelle Memorial Institute
+ * @copyright SPDX-FileCopyrightText: 2022 University of Washington
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * @authors
+ *   Andrew Lumsdaine
+ *
+ */
+
+#include <vector>
+
+#include "common/test_header.hpp"
+
+#include "nwgraph/adjacency.hpp"
+#include "nwgraph/algorithms/betweenness_centrality.hpp"
+#include "nwgraph/edge_list.hpp"
+
+using namespace nw::graph;
+
+// Helper to create a simple line graph: 0 -- 1 -- 2 -- 3 -- 4
+// In a line graph, the middle vertex has highest betweenness centrality
+auto create_line_graph() {
+  edge_list<directedness::directed> edges(5);
+  edges.open_for_push_back();
+  // Bidirectional edges for undirected behavior
+  edges.push_back(0, 1);
+  edges.push_back(1, 0);
+  edges.push_back(1, 2);
+  edges.push_back(2, 1);
+  edges.push_back(2, 3);
+  edges.push_back(3, 2);
+  edges.push_back(3, 4);
+  edges.push_back(4, 3);
+  edges.close_for_push_back();
+  return edges;
+}
+
+// Helper to create a star graph with center at vertex 0
+// Center has highest BC, all leaves have zero BC
+auto create_star_graph() {
+  edge_list<directedness::directed> edges(5);
+  edges.open_for_push_back();
+  // 0 is the center, connected to 1, 2, 3, 4
+  edges.push_back(0, 1);
+  edges.push_back(1, 0);
+  edges.push_back(0, 2);
+  edges.push_back(2, 0);
+  edges.push_back(0, 3);
+  edges.push_back(3, 0);
+  edges.push_back(0, 4);
+  edges.push_back(4, 0);
+  edges.close_for_push_back();
+  return edges;
+}
+
+// Helper to create a simple triangle graph
+auto create_triangle_graph() {
+  edge_list<directedness::directed> edges(3);
+  edges.open_for_push_back();
+  edges.push_back(0, 1);
+  edges.push_back(1, 0);
+  edges.push_back(1, 2);
+  edges.push_back(2, 1);
+  edges.push_back(2, 0);
+  edges.push_back(0, 2);
+  edges.close_for_push_back();
+  return edges;
+}
+
+TEST_CASE("Brandes betweenness centrality basic", "[betweenness]") {
+
+  SECTION("Line graph - middle vertex has highest BC") {
+    auto edges = create_line_graph();
+    adjacency<0> G(edges);
+
+    auto bc = brandes_bc<adjacency<0>, float, size_t>(G, false);
+
+    REQUIRE(bc.size() == 5);
+
+    // In a line graph 0-1-2-3-4, vertex 2 is on the most shortest paths
+    // Vertex 0 and 4 have BC = 0 (endpoints)
+    // Vertex 2 should have highest BC
+    REQUIRE(bc[0] == 0.0f);
+    REQUIRE(bc[4] == 0.0f);
+    REQUIRE(bc[2] > bc[1]);
+    REQUIRE(bc[2] > bc[3]);
+    // Symmetry: bc[1] == bc[3]
+    REQUIRE(bc[1] == bc[3]);
+  }
+
+  SECTION("Star graph - center has highest BC") {
+    auto edges = create_star_graph();
+    adjacency<0> G(edges);
+
+    auto bc = brandes_bc<adjacency<0>, float, size_t>(G, false);
+
+    REQUIRE(bc.size() == 5);
+
+    // All shortest paths between leaf nodes go through center (vertex 0)
+    // Leaf nodes have BC = 0
+    REQUIRE(bc[1] == 0.0f);
+    REQUIRE(bc[2] == 0.0f);
+    REQUIRE(bc[3] == 0.0f);
+    REQUIRE(bc[4] == 0.0f);
+    // Center should have highest BC
+    REQUIRE(bc[0] > 0.0f);
+  }
+
+  SECTION("Triangle graph - all vertices have equal BC") {
+    auto edges = create_triangle_graph();
+    adjacency<0> G(edges);
+
+    auto bc = brandes_bc<adjacency<0>, float, size_t>(G, false);
+
+    REQUIRE(bc.size() == 3);
+
+    // In a complete triangle, all vertices have same BC (0)
+    // because there are direct edges between all pairs
+    REQUIRE(bc[0] == 0.0f);
+    REQUIRE(bc[1] == 0.0f);
+    REQUIRE(bc[2] == 0.0f);
+  }
+}
+
+TEST_CASE("Brandes BC with normalization", "[betweenness]") {
+
+  SECTION("Normalized BC values are in [0,1]") {
+    auto edges = create_line_graph();
+    adjacency<0> G(edges);
+
+    auto bc = brandes_bc<adjacency<0>, float, size_t>(G, true);
+
+    REQUIRE(bc.size() == 5);
+
+    for (auto& score : bc) {
+      REQUIRE(score >= 0.0f);
+      REQUIRE(score <= 1.0f);
+    }
+
+    // Highest BC vertex should have score 1.0 after normalization
+    float max_bc = *std::max_element(bc.begin(), bc.end());
+    REQUIRE(max_bc == 1.0f);
+  }
+}
+
+TEST_CASE("BC single vertex graph", "[betweenness]") {
+
+  SECTION("Single vertex has BC = 0") {
+    edge_list<directedness::directed> edges(1);
+    adjacency<0> G(edges);
+
+    auto bc = brandes_bc<adjacency<0>, float, size_t>(G, false);
+
+    REQUIRE(bc.size() == 1);
+    REQUIRE(bc[0] == 0.0f);
+  }
+}
+
+TEST_CASE("BC disconnected graph", "[betweenness]") {
+
+  SECTION("Disconnected components") {
+    // Two separate edges: 0-1 and 2-3
+    edge_list<directedness::directed> edges(4);
+    edges.open_for_push_back();
+    edges.push_back(0, 1);
+    edges.push_back(1, 0);
+    edges.push_back(2, 3);
+    edges.push_back(3, 2);
+    edges.close_for_push_back();
+
+    adjacency<0> G(edges);
+
+    auto bc = brandes_bc<adjacency<0>, float, size_t>(G, false);
+
+    REQUIRE(bc.size() == 4);
+
+    // All vertices have BC = 0 (no vertex lies on paths between others)
+    REQUIRE(bc[0] == 0.0f);
+    REQUIRE(bc[1] == 0.0f);
+    REQUIRE(bc[2] == 0.0f);
+    REQUIRE(bc[3] == 0.0f);
+  }
+}