Improved Tests (#277)

* Improve tags test and  API

* Lists tests

Author: Affie

src/sandbox.jl renamed to attic/sandbox.jl

@@ -114,34 +114,38 @@ Related
 ls, lsf
 """
 sortDFG(vars::Vector{Symbol})::Vector{Symbol} = sortVarNested(vars)
-"""
-    $SIGNATURES
-
-Return the factor type used in a `::DFGFactor`.
-
-Notes:
-- OBSOLETE, use newer getFactorType instead.
-
-Related
 
-getFactorType
-"""
-function getfnctype(data::GenericFunctionNodeData)
-  # TODO what is this?
-  if typeof(data).name.name == :VariableNodeData
-    return VariableNodeData
-  end
-
-  # this looks right
-  return data.fnc.usrfnc!
-end
-function getfnctype(fact::DFGFactor; solveKey::Symbol=:default)
-  data = getSolverData(fact) # TODO , solveKey=solveKey)
-  return getfnctype(data)
-end
-function getfnctype(dfg::T, lbl::Symbol; solveKey::Symbol=:default) where T <: AbstractDFG
-  getfnctype(getFactor(dfg, exvertid))
-end
+#TODO Is this deprecate in favor of getFactorType, or OBSOLETE?
+# """
+#     $SIGNATURES
+#
+# Return the factor type used in a `::DFGFactor`.
+#
+# Notes:
+# - OBSOLETE, use newer getFactorType instead.
+#
+# Related
+#
+# getFactorType
+# """
+# function getfnctype(data::GenericFunctionNodeData)
+#   # TODO what is this?
+#   if typeof(data).name.name == :VariableNodeData
+#     return VariableNodeData
+#   end
+#
+#   # this looks right
+#   return data.fnc.usrfnc!
+# end
+# function getfnctype(fact::DFGFactor; solveKey::Symbol=:default)
+#   data = getSolverData(fact) # TODO , solveKey=solveKey)
+#   return getfnctype(data)
+# end
+# function getfnctype(dfg::T, lbl::Symbol; solveKey::Symbol=:default) where T <: AbstractDFG
+#   getfnctype(getFactor(dfg, exvertid))
+# end
+
+@deprecate getfnctype(args...) getFactorType(args...)
 
 """
     $SIGNATURES
@@ -190,9 +194,9 @@ end
 
 Return the DFGVariable softtype in factor graph `dfg<:AbstractDFG` and label `::Symbol`.
 """
-getVariableType(var::DFGVariable; solveKey::Symbol=:default) = getSofttype(var, solveKey=solveKey)
-function getVariableType(dfg::G, lbl::Symbol; solveKey::Symbol=:default) where G <: AbstractDFG
-  getVariableType(getVariable(dfg, lbl), solveKey=solveKey)
+getVariableType(var::DFGVariable) = getSofttype(var)
+function getVariableType(dfg::G, lbl::Symbol) where G <: AbstractDFG
+  getVariableType(getVariable(dfg, lbl))
 end
 
 
@@ -241,9 +245,9 @@ function lsTypes(dfg::G)::Dict{Symbol, Vector{String}} where G <: AbstractDFG
 end
 
 
-function ls(dfg::G, ::Type{T}; solveKey::Symbol=:default) where {G <: AbstractDFG, T <: InferenceVariable}
+function ls(dfg::G, ::Type{T}) where {G <: AbstractDFG, T <: InferenceVariable}
   xx = getVariables(dfg)
-  mask = getVariableType.(xx, solveKey=solveKey) .|> typeof .== T
+  mask = getVariableType.(xx) .|> typeof .== T
   vxx = view(xx, mask)
   map(x->x.label, vxx)
 end
@@ -274,11 +278,11 @@ Related
 
 ls, lsf, lsfPriors
 """
-function lsWho(dfg::AbstractDFG, type::Symbol; solveKey::Symbol=:default)::Vector{Symbol}
+function lsWho(dfg::AbstractDFG, type::Symbol)::Vector{Symbol}
     vars = getVariables(dfg)
     labels = Symbol[]
     for v in vars
-        varType = typeof(getVariableType(v, solveKey=solveKey)).name |> Symbol
+        varType = typeof(getVariableType(v)).name |> Symbol
         varType == type && push!(labels, v.label)
     end
     return labels
@@ -390,48 +394,56 @@ function findVariableNearTimestamp(dfg::AbstractDFG,
   return RET
 end
 
+
+#TAGS as a set, list, merge, remove, empty
 """
 $SIGNATURES
 
 Return the tags for a variable or factor.
 """
-function getTags(dfg::InMemoryDFGTypes, sym::Symbol)
+function listTags(dfg::InMemoryDFGTypes, sym::Symbol)
   getFnc = isVariable(dfg,sym) ? getVariable : getFactor
   getTags(getFnc(dfg, sym))
 end
+#alias for completeness
+listTags(f::DataLevel0) = getTags(f)
 
 """
     $SIGNATURES
 
-Add tags to a variable or factor
+Merge add tags to a variable or factor (union)
 """
-function addTags!(dfg::InMemoryDFGTypes, sym::Symbol, tags::Vector{Symbol})
+function mergeTags!(dfg::InMemoryDFGTypes, sym::Symbol, tags::Vector{Symbol})
   getFnc = isVariable(dfg,sym) ? getVariable : getFactor
   union!(getTags(getFnc(dfg, sym)), tags)
 end
+mergeTags!(f::DataLevel0, tags::Vector{Symbol}) = union!(f.tags, tags)
 
 
 """
 $SIGNATURES
 
-Add tag to a variable or factor
+Remove the tags from the node (setdiff)
 """
-addTag!(f::DataLevel0, tag::Symbol) = union!(f.tags,[tag])
-
+function removeTags!(dfg::InMemoryDFGTypes, sym::Symbol, tags::Vector{Symbol})
+  getFnc = isVariable(dfg,sym) ? getVariable : getFactor
+  setdiff!(getTags(getFnc(dfg, sym)), tags)
+end
+removeTags!(f::DataLevel0, tags::Vector{Symbol}) = setdiff!(f.tags, tags)
 
 """
 $SIGNATURES
 
-Merge tags to the node's tags (variable/factor).
+Empty all tags from the node (empty)
 """
-mergeTags!(f::DataLevel0, tags::Vector{Symbol}) = union!(f.tags, tags)
+function emptyTags!(dfg::InMemoryDFGTypes, sym::Symbol)
+  getFnc = isVariable(dfg,sym) ? getVariable : getFactor
+  empty!(getTags(getFnc(dfg, sym)))
+end
+emptyTags!(f::DataLevel0) = empty!(f.tags)
+
 
-"""
-$SIGNATURES
 
-Remove the tags from the node
-"""
-deleteTags!(f::DataLevel0, tags::Vector{Symbol}) = setdiff!(f.tags, tags)
 
 
 """
@@ -444,7 +456,7 @@ function hasTags(dfg::InMemoryDFGTypes,
                  tags::Vector{Symbol};
                  matchAll::Bool=true  )::Bool
   #
-  alltags = getTags(dfg, sym)
+  alltags = listTags(dfg, sym)
   length(filter(x->x in alltags, tags)) >= (matchAll ? length(tags) : 1)
 end
 

src/Common.jl

@@ -86,6 +86,8 @@ export pack, unpack
 # Resolve with above
 export packVariable, unpackVariable, packFactor, unpackFactor
 
+# TODO TAGS
+export listTags, mergeTags!, removeTags!, emptyTags!
 # PPE exports
 export AbstractPointParametricEst
 export MeanMaxPPE

src/DistributedFactorGraphs.jl

@@ -30,7 +30,7 @@ end
 
 @testset "Testing CRUD, return and Failures from a GraphsDFG" begin
     global dfg
-    # fg to copy to
+    # dfg to copy to
     # creating a whole new graph with the same labels
     T = typeof(dfg)
     if T <: CloudGraphsDFG
@@ -124,6 +124,44 @@ end
     @test !isVariable(dfg, f1.label)
     @test !isVariable(dfg, :doesntexist)
     @test !isFactor(dfg, :doesntexist)
+
+    @test issetequal([:a,:b], listVariables(dfg))
+    @test issetequal([:abf1], listFactors(dfg))
+
+    @test @test_deprecated getVariableIds(dfg) == listVariables(dfg)
+    @test @test_deprecated getFactorIds(dfg) == listFactors(dfg)
+
+
+    @test @test_deprecated getfnctype(f1.solverData) === getFactorType(f1.solverData)
+    @test @test_deprecated getfnctype(f1) === getFactorType(f1)
+    @test @test_deprecated getfnctype(dfg, :abf1) === getFactorType(dfg, :abf1)
+
+    @test getFactorType(f1.solverData) === f1.solverData.fnc.usrfnc!
+    @test getFactorType(f1) === f1.solverData.fnc.usrfnc!
+    @test getFactorType(dfg, :abf1) === f1.solverData.fnc.usrfnc!
+
+    @test !isPrior(dfg, :abf1) # f1 is not a prior
+    @test lsfPriors(dfg) == []
+    #FIXME don't know what it is supposed to do
+    @test_broken lsfTypes(dfg)
+
+    @test ls(dfg, LinearConditional) == [:abf1]
+    @test lsf(dfg, LinearConditional) == [:abf1]
+    @test lsfWho(dfg, :LinearConditional) == [:abf1]
+
+    @test getVariableType(v1) isa ContinuousScalar
+    @test getVariableType(dfg,:a) isa ContinuousScalar
+
+    #TODO what is lsTypes supposed to return?
+    @test_broken lsTypes(dfg)
+
+    @test issetequal(ls(dfg, ContinuousScalar), [:a, :b])
+
+    @test issetequal(lsWho(dfg, :ContinuousScalar),[:a, :b])
+
+    varNearTs = findVariableNearTimestamp(dfg, now())
+    @test_skip varNearTs[1][1]  == [:b]
+
 end
 
 # Gets
@@ -346,7 +384,7 @@ end
 
 # Now make a complex graph for connectivity tests
 numNodes = 10
-#the deletions in last test should have cleared out the fg
+#the deletions in last test should have cleared out the dfg
 # dfg = DistributedFactorGraphs._getDuplicatedEmptyDFG(dfg)
 # if typeof(dfg) <: CloudGraphsDFG
 #     clearSession!!(dfg)

test/iifInterfaceTests.jl

@@ -332,9 +332,55 @@ end
 end
 
 
-##
 @testset "TODO Sorteer groep" begin
 
+    @testset "Listing Variables and Factors with filters" begin
+
+        @test issetequal([:a,:b], listVariables(fg))
+        @test issetequal([:f1], listFactors(fg))
+
+        @test @test_deprecated getVariableIds(fg) == listVariables(fg)
+        @test @test_deprecated getFactorIds(fg) == listFactors(fg)
+
+        # TODO Mabye implement IIF type here
+        # Requires IIF or a type in IIF
+        @test_skip @test_deprecated getfnctype(f1.solverData) === getFactorType(f1.solverData)
+        @test_skip @test_deprecated getfnctype(f1) === getFactorType(f1)
+        @test_skip @test_deprecated getfnctype(fg, :f1) === getFactorType(fg, :f1)
+        @test_broken getFactorType(f1.solverData) === f1.solverData.fnc.usrfnc!
+        @test_broken getFactorType(f1) === f1.solverData.fnc.usrfnc!
+        @test_broken getFactorType(fg, :f1) === f1.solverData.fnc.usrfnc!
+
+        @test_broken isPrior(fg, :f1) # if f1 is prior
+        @test_broken lsfPriors(fg) == [:f1]
+        @test_broken lsfTypes(fg)
+
+        @test_broken ls(fg, TestFunctorInferenceType1) == [f1]
+        @test_broken lsf(fg, TestFunctorInferenceType1) == [f1]
+        @test_broken lsfWho(fg, :TestFunctorInferenceType1) == [f1]
+
+        @test getVariableType(v1) == TestInferenceVariable1()
+        @test getVariableType(fg,:a) == TestInferenceVariable1()
+
+        #TODO what is lsTypes supposed to return?
+        lsTypes(fg)
+
+        @test ls(fg, TestInferenceVariable1) == [:a]
+
+        @test lsWho(fg, :TestInferenceVariable1) == [:a]
+
+        varNearTs = findVariableNearTimestamp(fg, now())
+        @test varNearTs[1][1]  == [:b]
+
+        #TODO test filters and options
+        # regexFilter::Union{Nothing, Regex}=nothing;
+        # tags::Vector{Symbol}=Symbol[],
+        # solvable::Int=0,
+        # warnDuplicate::Bool=true,
+        # number::Int=1
+
+    end
+
     @testset "Connectivity Test" begin
 
         if testDFGAPI == GraphsDFG
@@ -397,22 +443,24 @@ end
         @test sort(l, lt=DistributedFactorGraphs.natural_lt) == [Symbol("1a1"), :X1, :a, :a1, :b1c2, :c, :l1, :x1, :x1_1, :x1_2, :x1l1f1, :x1x2f1, :x2_1, :x2_2, :x10, :x10_10, :xy3]
     end
 end
-#
+
 @testset "tags" begin
     #
-    # LOTS TODO
 
-    @test issetequal(getTags(fg, :a), v1_tags)
+    v1Tags = deepcopy(getTags(v1))
+    @test issetequal(v1Tags, v1_tags)
+    @test issetequal(listTags(fg, :a), v1Tags)
+    @test issetequal(mergeTags!(fg, :a, [:TAG]), v1Tags ∪ [:TAG])
+    @test issetequal(removeTags!(fg, :a, [:TAG]), v1Tags)
+    @test emptyTags!(fg, :a) == Set{Symbol}()
 
-    # TODO do we error on duplicates
-    @test issetequal(addTags!(fg, :a, [:TAG]), v1_tags ∪ [:TAG])
 
-    @test_broken emptyTags!(fg, :a)
+    v2Tags = [listTags(fg, :b)...]
+    @test hasTags(fg, :b, [v2Tags...])
+    @test hasTags(fg, :b, [:LANDMARK, :TAG], matchAll=false)
 
-    @test_broken updateTags!
-    @test_broken deleteTags!
-    @test_broken listTags
-    @test_broken mergeTags!
+    @test hasTagsNeighbors(fg, :f1, [:LANDMARK])
+    @test !hasTagsNeighbors(fg, :f1, [:LANDMARK, :TAG])
 
 end