Move validation functions to ./test (#79)

AntonReinhard · web-flow · commit 6c2049da87d8 · 2025-11-11T14:10:46.000+01:00
diff --git a/docs/src/lib/internals/graph.md b/docs/src/lib/internals/graph.md
@@ -41,10 +41,3 @@ Modules = [ComputableDAGs]
 Pages = ["graph/properties.jl"]
 Order   = [:function]
 ```
-
-## Validate
-```@autodocs
-Modules = [ComputableDAGs]
-Pages = ["graph/validate.jl"]
-Order   = [:function]
-```
diff --git a/docs/src/lib/internals/node.md b/docs/src/lib/internals/node.md
@@ -34,10 +34,3 @@ Modules = [ComputableDAGs]
 Pages = ["node/print.jl"]
 Order   = [:function]
 ```
-
-## Validate
-```@autodocs
-Modules = [ComputableDAGs]
-Pages = ["node/validate.jl"]
-Order   = [:function]
-```
diff --git a/docs/src/lib/internals/operation.md b/docs/src/lib/internals/operation.md
@@ -48,10 +48,3 @@ Modules = [ComputableDAGs]
 Pages = ["operation/print.jl"]
 Order   = [:function]
 ```
-
-## Validate
-```@autodocs
-Modules = [ComputableDAGs]
-Pages = ["operation/validate.jl"]
-Order   = [:function]
-```
diff --git a/src/ComputableDAGs.jl b/src/ComputableDAGs.jl
@@ -69,13 +69,11 @@ include("graph/interface.jl")
 include("graph/mute.jl")
 include("graph/print.jl")
 include("graph/properties.jl")
-include("graph/validate.jl")
 
 include("node/compare.jl")
 include("node/create.jl")
 include("node/print.jl")
 include("node/properties.jl")
-include("node/validate.jl")
 
 include("operation/utility.jl")
 include("operation/iterate.jl")
@@ -84,7 +82,6 @@ include("operation/clean.jl")
 include("operation/find.jl")
 include("operation/get.jl")
 include("operation/print.jl")
-include("operation/validate.jl")
 
 include("properties/create.jl")
 include("properties/utility.jl")
diff --git a/src/node/validate.jl b/src/node/validate.jl
diff --git a/src/operation/apply.jl b/src/operation/apply.jl
@@ -116,8 +116,6 @@ Reduce the given nodes together into one node, return the applied difference to
 For details see [`NodeReduction`](@ref).
 """
 function node_reduction!(dag::DAG, nodes::Vector{NodeType}) where {NodeType <: Node}
-    @assert is_valid_node_reduction_input(dag, nodes)
-
     # clear snapshot
     snapshot_diff(dag)
 
@@ -172,8 +170,6 @@ For details see [`NodeSplit`](@ref).
 function node_split!(
         dag::DAG, n1::NodeType
     ) where {NodeType <: Node}
-    @assert is_valid_node_split_input(dag, n1)
-
     # clear snapshot
     snapshot_diff(dag)
 
diff --git a/src/operation/type.jl b/src/operation/type.jl
@@ -35,8 +35,6 @@ A vector of nodes can be reduced if:
 - All nodes have the same task type.
 - All nodes have the same set of children.
 
-[`is_valid_node_reduction_input`](@ref) can be used to `@assert` these requirements.
-
 See also: [`can_reduce`](@ref)
 """
 struct NodeReduction <: Operation
@@ -64,8 +62,6 @@ A node can be split if:
 - It is in the graph.
 - It has at least 2 parents.
 
-[`is_valid_node_split_input`](@ref) can be used to `@assert` these requirements.
-
 See also: [`can_split`](@ref)
 """
 struct NodeSplit <: Operation
diff --git a/test/optimization.jl b/test/optimization.jl
@@ -24,8 +24,9 @@ RNG = Xoshiro(1)
             dag, instance, cpu_st(), @__MODULE__
         )
 
-        input = [rand(RNG, Float64, 3 * N) for _ in 1:100]
+        LEN = 128
+        input = [rand(RNG, Float64, 3 * N) for _ in 1:LEN]
 
-        @test isapprox(f.(input), reduced_f.(input))
+        @test count([isapprox(orig, reduced) || isnan(orig) && isnan(reduced) for (orig, reduced) in Iterators.zip(f.(input), reduced_f.(input))]) == LEN
     end
 end
diff --git a/test/strassen_test.jl b/test/strassen_test.jl
@@ -1,8 +1,9 @@
 using ComputableDAGs
 using StaticArrays
 
-using ComputableDAGs: is_valid, input_expr, input_type
+using ComputableDAGs: input_expr, input_type
 
+include("validate/impl.jl")
 include("strassen/impl.jl")
 using .MatrixMultiplicationImpl
 
diff --git a/test/validate/graph.jl b/test/validate/graph.jl
@@ -1,8 +1,6 @@
-"""
-    is_connected(dag::DAG)
+using DataStructures
+using UUIDs
 
-Return whether the given graph is connected.
-"""
 function is_connected(dag::DAG)
     node_queue = Deque{UUID}()
     push!(node_queue, exit_node(dag).id)
@@ -20,11 +18,6 @@ function is_connected(dag::DAG)
     return length(seen_nodes) == length(dag.nodes)
 end
 
-"""
-    is_valid(dag::DAG)
-
-Validate the entire graph using asserts. Intended for testing with `@assert is_valid(dag)`.
-"""
 function is_valid(dag::DAG)
     for (id, node) in dag.nodes
         @assert is_valid(dag, node)
diff --git a/test/validate/impl.jl b/test/validate/impl.jl
@@ -0,0 +1,5 @@
+# Some implementations of validation functions that can be used to check that objects are in a valid state.
+
+include("graph.jl")
+include("node.jl")
+include("operation.jl")
diff --git a/test/validate/node.jl b/test/validate/node.jl
@@ -0,0 +1,31 @@
+function is_valid_node(dag::DAG, node::Node)
+    @assert node in dag "Node is not part of the given graph!"
+
+    for parent_id in node.parents
+        parent = dag.nodes[parent_id]
+        @assert typeof(parent) != typeof(node) "Node's type is the same as its parent's!"
+        @assert haskey(dag.nodes, parent_id) "Node's parent is not in the same graph!"
+        @assert ComputableDAGs.is_child(dag, node, parent) "Node is not a child of its parent!"
+    end
+
+    for (child_id, index) in node.children
+        child = dag.nodes[child_id]
+        @assert typeof(child) != typeof(node) "Node's type is the same as its child's!"
+        @assert haskey(dag.nodes, child_id) "Node's child is not in the same graph!"
+        @assert ComputableDAGs.is_parent(dag, node, child) "Node is not a parent of its child!"
+    end
+
+    return true
+end
+
+function is_valid(dag::DAG, node::ComputableDAGs.ComputeTaskNode)
+    @assert is_valid_node(dag, node)
+
+    return true
+end
+
+function is_valid(dag::DAG, node::ComputableDAGs.DataTaskNode)
+    @assert is_valid_node(dag, node)
+
+    return true
+end
diff --git a/test/validate/operation.jl b/test/validate/operation.jl
@@ -1,14 +1,3 @@
-# functions to throw assertion errors for inconsistent or wrong node operations
-# should be called with @assert
-# the functions throw their own errors though, to still have helpful error messages
-
-"""
-    is_valid_node_reduction_input(dag::DAG, nodes::Vector{Node})
-
-Assert for a given node reduction input whether the nodes can be reduced. For the requirements of a node reduction see [`NodeReduction`](@ref).
-
-Intended for use with `@assert` or `@test`.
-"""
 function is_valid_node_reduction_input(dag::DAG, nodes::Vector{NodeType}) where {NodeType <: Node}
     for n in nodes
         if n ∉ dag
@@ -40,9 +29,9 @@ function is_valid_node_reduction_input(dag::DAG, nodes::Vector{NodeType}) where
         end
     end
 
-    n1_children = children(dag, nodes[1])
+    n1_children = ComputableDAGs.children(dag, nodes[1])
     for n in nodes
-        if Set(n1_children) != Set(children(dag, n))
+        if Set(n1_children) != Set(ComputableDAGs.children(dag, n))
             throw(
                 AssertionError(
                     "[Node Reduction] the given nodes do not have equal prerequisite nodes which is required for node reduction",
@@ -54,13 +43,6 @@ function is_valid_node_reduction_input(dag::DAG, nodes::Vector{NodeType}) where
     return true
 end
 
-"""
-    is_valid_node_split_input(graph::DAG, n1::Node)
-
-Assert for a given node split input whether the node can be split. For the requirements of a node split see [`NodeSplit`](@ref).
-
-Intended for use with `@assert` or `@test`.
-"""
 function is_valid_node_split_input(dag::DAG, n1::Node)
     if n1 ∉ dag
         throw(AssertionError("[Node Split] the given node is not part of the given graph"))
@@ -79,26 +61,12 @@ function is_valid_node_split_input(dag::DAG, n1::Node)
     return true
 end
 
-"""
-    is_valid(dag::DAG, nr::NodeReduction)
-
-Assert for a given [`NodeReduction`](@ref) whether it is a valid operation in the graph.
-
-Intended for use with `@assert` or `@test`.
-"""
-function is_valid(dag::DAG, nr::NodeReduction)
+function is_valid(dag::DAG, nr::ComputableDAGs.NodeReduction)
     @assert is_valid_node_reduction_input(dag, getindex.(Ref(dag.nodes), nr.input))
     return true
 end
 
-"""
-    is_valid(dag::DAG, nr::NodeSplit)
-
-Assert for a given [`NodeSplit`](@ref) whether it is a valid operation in the graph.
-
-Intended for use with `@assert` or `@test`.
-"""
-function is_valid(dag::DAG, ns::NodeSplit)
+function is_valid(dag::DAG, ns::ComputableDAGs.NodeSplit)
     @assert is_valid_node_split_input(dag, dag.nodes[ns.input])
     return true
 end
