Add regressions for overflow and zero-cost cycles

Co-authored-by: Andrey G <networmix@gmail.com>

Author: cursoragent

tests/cpp/flow_policy_tests.cpp

@@ -1,4 +1,5 @@
 #include <gtest/gtest.h>
+#include <limits>
 
 #include "netgraph/core/flow_graph.hpp"
 #include "netgraph/core/flow_policy.hpp"
@@ -349,3 +350,36 @@ TEST(FlowPolicyCore, EqualBalanced_ShortestPath_IgnoresHigherCostTier) {
   // Only shortest tier edges should carry flow
   expect_edge_flows_by_uv(fg, {{0,1,10.0}, {1,4,10.0}, {0,2,0.0}, {2,4,0.0}});
 }
+
+TEST(FlowPolicyCore, MaxPathCostFactor_DoesNotOverflowAndRejectValidPath) {
+  const auto kMax = std::numeric_limits<Cost>::max();
+  // Single edge with very large cost; max_path_cost_factor should not overflow
+  // and incorrectly reject this valid path.
+  std::int32_t num_nodes = 2;
+  std::int32_t src_arr[1] = {0};
+  std::int32_t dst_arr[1] = {1};
+  double cap_arr[1] = {1.0};
+  std::int64_t cost_arr[1] = {kMax - 5};
+  std::int64_t ext_arr[1] = {0};
+  auto g = StrictMultiDiGraph::from_arrays(num_nodes,
+                                           std::span<const std::int32_t>(src_arr, 1),
+                                           std::span<const std::int32_t>(dst_arr, 1),
+                                           std::span<const double>(cap_arr, 1),
+                                           std::span<const std::int64_t>(cost_arr, 1),
+                                           std::span<const std::int64_t>(ext_arr, 1));
+  FlowGraph fg(g);
+  auto be = make_cpu_backend();
+  auto algs = std::make_shared<Algorithms>(be);
+  auto gh = algs->build_graph(g);
+  ExecutionContext ctx(algs, gh);
+
+  FlowPolicyConfig cfg;
+  cfg.flow_placement = FlowPlacement::Proportional;
+  cfg.max_flow_count = 1;
+  cfg.max_path_cost_factor = 2.0;
+  FlowPolicy policy(ctx, cfg);
+
+  auto res = policy.place_demand(fg, 0, 1, 0, 1.0);
+  EXPECT_NEAR(res.first, 1.0, 1e-9);
+  EXPECT_NEAR(res.second, 0.0, 1e-9);
+}

tests/cpp/k_shortest_paths_tests.cpp

@@ -305,3 +305,24 @@ TEST(KShortestPaths, LargerOutOfOrderTopology) {
     }
   }
 }
+
+TEST(KShortestPaths, OverflowSaturatesWithoutNegativeWrap) {
+  const auto kMax = std::numeric_limits<Cost>::max();
+  // Single path with mathematically overflowing sum.
+  std::int32_t src_arr[2] = {0, 1};
+  std::int32_t dst_arr[2] = {1, 2};
+  double cap_arr[2] = {1.0, 1.0};
+  std::int64_t cost_arr[2] = {kMax - 5, 10};
+  auto g = StrictMultiDiGraph::from_arrays(3,
+    std::span(src_arr, 2), std::span(dst_arr, 2),
+    std::span(cap_arr, 2), std::span(cost_arr, 2));
+
+  auto items = k_shortest_paths(g, 0, 2, 1, std::nullopt, true);
+  ASSERT_EQ(items.size(), 1u);
+  const auto& [dist, dag] = items.front();
+
+  EXPECT_EQ(dist[0], 0);
+  EXPECT_EQ(dist[1], kMax - 5);
+  EXPECT_EQ(dist[2], kMax - 1) << "Overflow should saturate to finite max";
+  expect_pred_dag_semantically_valid(g, dag, dist);
+}

tests/cpp/max_flow_tests.cpp

@@ -219,6 +219,35 @@ TEST(MaxFlow, ECMP_TwoPaths_EqualBalanced_ShortestPath) {
   validate_flow_conservation(g, summary, 0, 3);
 }
 
+TEST(MaxFlow, EqualBalanced_ZeroCostCycleStillFindsFeasibleFlow) {
+  // Shortest-tier zero-cost cycle between 1 and 2:
+  // 0->1 (0), 1->2 (0), 2->1 (0), exits 1->3 (1), 2->3 (1)
+  std::int32_t src_arr[5] = {0, 1, 2, 2, 1};
+  std::int32_t dst_arr[5] = {1, 2, 1, 3, 3};
+  double cap_arr[5] = {1.0, 1.0, 1.0, 1.0, 1.0};
+  std::int64_t cost_arr[5] = {0, 0, 0, 1, 1};
+  auto g = StrictMultiDiGraph::from_arrays(4,
+    std::span(src_arr, 5), std::span(dst_arr, 5),
+    std::span(cap_arr, 5), std::span(cost_arr, 5));
+
+  auto be = make_cpu_backend();
+  Algorithms algs(be);
+  auto gh = algs.build_graph(g);
+
+  MaxFlowOptions opts_prop;
+  opts_prop.placement = FlowPlacement::Proportional;
+  opts_prop.shortest_path = false;
+  auto [total_prop, _] = algs.max_flow(gh, 0, 3, opts_prop);
+  EXPECT_NEAR(total_prop, 1.0, 1e-9);
+
+  MaxFlowOptions opts_eq;
+  opts_eq.placement = FlowPlacement::EqualBalanced;
+  opts_eq.shortest_path = false;
+  auto [total_eq, __] = algs.max_flow(gh, 0, 3, opts_eq);
+  EXPECT_NEAR(total_eq, 1.0, 1e-9)
+      << "Equal-balanced should not collapse to zero flow on zero-cost cycle";
+}
+
 TEST(MaxFlow, ECMP_ThreePaths_Proportional_ShortestPath) {
   // Extends ECMP validation to 3 equal-cost paths
   auto g = make_n_disjoint_paths(3, 10.0);

tests/cpp/shortest_paths_tests.cpp

@@ -1,5 +1,6 @@
 #include <gtest/gtest.h>
 #include <limits>
+#include <set>
 #include "netgraph/core/shortest_paths.hpp"
 #include "netgraph/core/strict_multidigraph.hpp"
 #include "netgraph/core/backend.hpp"
@@ -298,3 +299,59 @@ TEST(ShortestPaths, RejectsMaskLengthMismatch) {
   opts2.edge_mask = std::span<const bool>(edge_mask.get(), static_cast<std::size_t>(g.num_edges() - 1));
   EXPECT_THROW({ (void)algs.spf(gh, 0, opts2); }, std::invalid_argument);
 }
+
+TEST(ShortestPaths, OverflowSaturatesWithoutWrapping) {
+  const auto kMax = std::numeric_limits<Cost>::max();
+  // 0->1 has huge cost, 1->2 overflows if added, 0->2 is cheap alternative.
+  std::int32_t src[3] = {0, 1, 0};
+  std::int32_t dst[3] = {1, 2, 2};
+  double cap[3] = {1.0, 1.0, 1.0};
+  std::int64_t cost[3] = {kMax - 5, 10, 100};
+
+  auto g = StrictMultiDiGraph::from_arrays(3,
+    std::span(src, 3), std::span(dst, 3),
+    std::span(cap, 3), std::span(cost, 3));
+
+  EdgeSelection sel;
+  sel.multi_edge = true;
+  sel.require_capacity = false;
+  sel.tie_break = EdgeTieBreak::Deterministic;
+
+  auto [dist, dag] = shortest_paths(g, 0, std::nullopt, true, sel, {}, {}, {});
+
+  EXPECT_EQ(dist[0], 0);
+  EXPECT_EQ(dist[1], kMax - 5);
+  EXPECT_EQ(dist[2], 100) << "Overflowed path must not wrap negative and win";
+
+  expect_pred_dag_semantically_valid(g, dag, dist);
+}
+
+TEST(ShortestPaths, ResolveToPathsSkipsZeroCostCycleBackEdges) {
+  // Topology with a zero-cost cycle on the shortest tier:
+  // 0->1->2->1 and exits 1->3, 2->3.
+  std::int32_t src[5] = {0, 1, 2, 2, 1};
+  std::int32_t dst[5] = {1, 2, 1, 3, 3};
+  double cap[5] = {1.0, 1.0, 1.0, 1.0, 1.0};
+  std::int64_t cost[5] = {0, 0, 0, 1, 1};
+  auto g = StrictMultiDiGraph::from_arrays(4,
+    std::span(src, 5), std::span(dst, 5),
+    std::span(cap, 5), std::span(cost, 5));
+
+  EdgeSelection sel;
+  sel.multi_edge = true;
+  sel.require_capacity = false;
+  sel.tie_break = EdgeTieBreak::Deterministic;
+  auto [dist, dag] = shortest_paths(g, 0, 3, true, sel, {}, {}, {});
+
+  expect_pred_dag_semantically_valid(g, dag, dist);
+
+  // Must terminate without max_paths and return only simple paths.
+  auto paths = resolve_to_paths(dag, 0, 3, false, std::nullopt);
+  EXPECT_EQ(paths.size(), 2u);
+  for (const auto& path : paths) {
+    std::set<NodeId> seen;
+    for (const auto& [node, _] : path) {
+      EXPECT_TRUE(seen.insert(node).second) << "Path contains a cycle";
+    }
+  }
+}

tests/cpp/test_utils.hpp

@@ -7,6 +7,7 @@
 #include "netgraph/core/shortest_paths.hpp"
 #include "netgraph/core/flow_graph.hpp"
 #include "netgraph/core/max_flow.hpp"
+#include "netgraph/core/cost_utils.hpp"
 
 namespace netgraph::core::test {
 
@@ -429,7 +430,7 @@ inline void expect_pred_dag_semantically_valid(const StrictMultiDiGraph& g,
       auto d_v = dist[static_cast<std::size_t>(v)];
       auto d_p = dist[static_cast<std::size_t>(parent)];
       if (d_v < std::numeric_limits<Cost>::max() && d_p < std::numeric_limits<Cost>::max()) {
-        EXPECT_EQ(d_v, d_p + edge_cost[eid])
+        EXPECT_EQ(d_v, saturating_cost_add(d_p, edge_cost[eid]))
             << "Distance inconsistency at node " << v;
       }
     }

tests/py/test_critical_regressions.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import numpy as np
+
+import netgraph_core as ngc
+
+
+def _graph_overflow_with_alternative():
+    kmax = np.iinfo(np.int64).max
+    src = np.array([0, 1, 0], dtype=np.int32)
+    dst = np.array([1, 2, 2], dtype=np.int32)
+    cap = np.array([1.0, 1.0, 1.0], dtype=np.float64)
+    cost = np.array([kmax - 5, 10, 100], dtype=np.int64)
+    ext = np.arange(3, dtype=np.int64)
+    return ngc.StrictMultiDiGraph.from_arrays(3, src, dst, cap, cost, ext)
+
+
+def _graph_overflow_single_path():
+    kmax = np.iinfo(np.int64).max
+    src = np.array([0, 1], dtype=np.int32)
+    dst = np.array([1, 2], dtype=np.int32)
+    cap = np.array([1.0, 1.0], dtype=np.float64)
+    cost = np.array([kmax - 5, 10], dtype=np.int64)
+    ext = np.arange(2, dtype=np.int64)
+    return ngc.StrictMultiDiGraph.from_arrays(3, src, dst, cap, cost, ext)
+
+
+def _graph_zero_cost_cycle():
+    src = np.array([0, 1, 2, 2, 1], dtype=np.int32)
+    dst = np.array([1, 2, 1, 3, 3], dtype=np.int32)
+    cap = np.array([1.0, 1.0, 1.0, 1.0, 1.0], dtype=np.float64)
+    cost = np.array([0, 0, 0, 1, 1], dtype=np.int64)
+    ext = np.arange(5, dtype=np.int64)
+    return ngc.StrictMultiDiGraph.from_arrays(4, src, dst, cap, cost, ext)
+
+
+def test_spf_overflow_does_not_wrap_negative(algs, to_handle):
+    g = _graph_overflow_with_alternative()
+    gh = to_handle(g)
+    dist, _ = algs.spf(gh, 0, dtype="int64")
+    assert int(dist[2]) == 100
+
+
+def test_ksp_overflow_saturates_finite_cost(algs, to_handle):
+    g = _graph_overflow_single_path()
+    gh = to_handle(g)
+    items = algs.ksp(gh, 0, 2, k=1, dtype="int64")
+    assert len(items) == 1
+    kmax = np.iinfo(np.int64).max
+    assert int(items[0][0][2]) == int(kmax - 1)
+
+
+def test_max_flow_summary_costs_no_negative_wrap(algs, to_handle):
+    g = _graph_overflow_single_path()
+    gh = to_handle(g)
+    flow, summary = algs.max_flow(gh, 0, 2)
+    assert flow == 1.0
+    assert int(summary.costs[0]) == int(np.iinfo(np.int64).max - 1)
+
+
+def test_flow_policy_max_cost_factor_handles_large_cost(algs, to_handle):
+    g = _graph_overflow_single_path()
+    gh = to_handle(g)
+    fg = ngc.FlowGraph(g)
+    cfg = ngc.FlowPolicyConfig(max_flow_count=1, max_path_cost_factor=2.0)
+    policy = ngc.FlowPolicy(algs, gh, cfg)
+    placed, left = policy.place_demand(fg, 0, 2, 0, 1.0)
+    assert placed == 1.0
+    assert left == 0.0
+
+
+def test_resolve_to_paths_terminates_on_zero_cost_cycle(algs, to_handle):
+    g = _graph_zero_cost_cycle()
+    gh = to_handle(g)
+    _, dag = algs.spf(gh, 0, dst=3, multipath=True, dtype="int64")
+    paths = dag.resolve_to_paths(0, 3)
+    assert len(paths) == 2
+    for path in paths:
+        nodes = [int(n) for n, _ in path]
+        assert len(nodes) == len(set(nodes))
+
+
+def test_equal_balanced_max_flow_zero_cost_cycle(algs, to_handle):
+    g = _graph_zero_cost_cycle()
+    gh = to_handle(g)
+    flow_prop, _ = algs.max_flow(
+        gh,
+        0,
+        3,
+        flow_placement=ngc.FlowPlacement.PROPORTIONAL,
+        shortest_path=False,
+        require_capacity=True,
+    )
+    flow_eb, _ = algs.max_flow(
+        gh,
+        0,
+        3,
+        flow_placement=ngc.FlowPlacement.EQUAL_BALANCED,
+        shortest_path=False,
+        require_capacity=True,
+    )
+    assert flow_prop == 1.0
+    assert flow_eb == 1.0