throw argument error and explicitly test enumerate_paths!

Author: rafaqz

src/Graphs.jl

@@ -253,6 +253,7 @@ export
     has_negative_edge_cycle_spfa,
     has_negative_edge_cycle,
     enumerate_paths,
+    enumerate_paths!,
     johnson_shortest_paths,
     floyd_warshall_shortest_paths,
     transitiveclosure!,

src/shortestpaths/bellman-ford.jl

@@ -107,6 +107,7 @@ single destinations, the path is represented by a single vector of vertices,
 and will be length 0 if the path does not exist.
 
 ### Implementation Notes
+
 For Floyd-Warshall path states, please note that the output is a bit different,
 since this algorithm calculates all shortest paths for all pairs of vertices:
 `enumerate_paths(state)` will return a vector (indexed by source vertex) of
@@ -130,7 +131,10 @@ end
 
 In-place version of [`enumerate_paths`](@ref).
 
-`paths` must be a `Vector{Vectors{eltype(state.parents)}}`
+`paths` must be a `Vector{Vectors{eltype(state.parents)}}`, `state` an `AbstractPathState`, 
+and `vs`` an AbstractRange or other AbstractVector of `Int`. 
+
+See the `enumerate_paths` documentation for details.
 
 `enumerate_paths!` should be more efficient when used in a loop,
 as the same memory can be used for each iteration.
@@ -142,7 +146,8 @@ function enumerate_paths!(
 )
     Base.require_one_based_indexing(all_paths)
     Base.require_one_based_indexing(vs)
-    @assert length(all_paths) == length(vs)
+    length(all_paths) == length(vs) || 
+        throw(ArgumentError("length of destination paths $(length(vs)) deos not match length of vs $(length(all_paths))"))
 
     parents = state.parents
     T = eltype(state.parents)
@@ -161,4 +166,4 @@ function enumerate_paths!(
         end
     end
     return all_paths
-end
+end

test/shortestpaths/bellman-ford.jl

@@ -1,4 +1,4 @@
-@testset "Bellman Ford" begin
+# @testset "Bellman Ford" begin
     g4 = path_digraph(5)
 
     d1 = float([0 1 2 3 4; 5 0 6 7 8; 9 10 0 11 12; 13 14 15 0 16; 17 18 19 20 0])
@@ -56,12 +56,15 @@
 
     d3 = [CustomReal(i, 3) for i in d1]
     d4 = sparse(d3)
+    g = first(test_generic_graphs(g4))
     for g in test_generic_graphs(g4)
         y = @inferred(bellman_ford_shortest_paths(g, 2, d3))
         z = @inferred(bellman_ford_shortest_paths(g, 2, d4))
         @test getfield.(y.dists, :val) == getfield.(z.dists, :val) == [Inf, 0, 6, 17, 33]
         @test @inferred(enumerate_paths(z))[2] == []
         @test @inferred(enumerate_paths(z))[4] == enumerate_paths(z, 4) == [2, 3, 4]
+        @test @inferred(enumerate_paths!([[0]], z, 4:4))[1]  == [2, 3, 4]
+        @test_throws ArgumentError enumerate_paths!([[0, 0], [0, 0]], z, 4:4)
         @test @inferred(!has_negative_edge_cycle(g))
         @test @inferred(!has_negative_edge_cycle(g, d3))