marks: wrap the dict into a Marks type

In prevision of introducing "hard" marks, which are marks
attached statically to a `@testset`, independent of subjects.

Author: rfourquet

src/ReTest.jl

@@ -71,8 +71,7 @@ mutable struct TestsetExpr
     parent::Maybe{TestsetExpr}
     children::Vector{TestsetExpr}
     strings::Vector{Union{String,Missing}}
-    # Union to avoid creating a vector in most cases
-    marks::Dict{String, Union{Symbol, Vector{Symbol}}} # TODO: should be a MultiDict
+    marks::Marks
     # loopvalues & loopiters: when successful in evaluating loop values in resolve!,
     # we "flatten" the nested for loops into a single loop, with loopvalues
     # containing tuples of values, and loopiters the tuples of variables to which the
@@ -88,7 +87,7 @@ mutable struct TestsetExpr
 
     TestsetExpr(source, mod, desc, options, loops, parent, children=TestsetExpr[]) =
         new(0, source, mod, desc, options, loops, parent, children, String[],
-            Dict{String, Union{Symbol, Vector{Symbol}}}())
+            Marks())
 end
 
 isfor(ts::TestsetExpr) = ts.loops !== nothing

src/marks.jl

@@ -1,25 +1,33 @@
+struct Marks
+    # Union to avoid creating a vector in most cases
+    soft::Dict{String, Union{Symbol, Vector{Symbol}}} # TODO: should be a MultiDict
+
+    Marks() = new(Dict{String, Union{Symbol, Vector{Symbol}}}())
+end
+
 const _pass = :__pass__
 const _fail = :__fail__
 
 # marks contains at most one of _pass, _fail
 
 # return true (pass), false (fail), or nothing (unrun)
-function pastresult(marks::Dict, subject)
-    ms = get(marks, subject, Symbol())
+function pastresult(marks::Marks, subject)
+    ms = get(marks.soft, subject, Symbol())
     sym::Symbol = ms isa Symbol ? ms : isempty(ms) ? Symbol() : ms[1]
     sym === _pass ? true : sym === _fail ? false : nothing
 end
 
-function setresult!(marks::Dict, subject, success::Bool)
-    ms = get(marks, subject, Symbol())
+function setresult!(marks::Marks, subject, success::Bool)
+    soft = marks.soft
+    ms = get(soft, subject, Symbol())
     res = success ? _pass : _fail
     if ms isa Symbol
         # ms could be Symbol() from get's default or delmark!
         if ms ∈ (_pass, _fail, Symbol())
-            marks[subject] = res
+            soft[subject] = res
         else
             # res always in first position
-            marks[subject] = [res, ms]
+            soft[subject] = [res, ms]
         end
     else # ms isa Vector
         if !isempty(ms) && ms[1] ∈ (_pass, _fail)
@@ -30,8 +38,8 @@ function setresult!(marks::Dict, subject, success::Bool)
     end
 end
 
-function markiter(marks, subject, skipres::Bool)
-    ms = get(marks, subject, Symbol())
+function markiter(marks::Marks, subject, skipres::Bool)
+    ms = get(marks.soft, subject, Symbol())
     if ms isa Symbol
         if ms === Symbol() || skipres && ms ∈ (_pass, _fail)
             ()
@@ -47,16 +55,17 @@ function markiter(marks, subject, skipres::Bool)
     end
 end
 
-function addmark!(marks, subject, m::Symbol)
-    ms = get(marks, subject, Symbol())
+function addmark!(marks::Marks, subject, m::Symbol)
+    soft = marks.soft
+    ms = get(soft, subject, Symbol())
     if ms isa Symbol
         if ms === m
             false
         elseif ms === Symbol()
-            marks[subject] = m
+            soft[subject] = m
             true
         else
-            marks[subject] = [ms, m]
+            soft[subject] = [ms, m]
             true
         end
     elseif findfirst(==(m), ms) === nothing
@@ -67,11 +76,12 @@ function addmark!(marks, subject, m::Symbol)
     end
 end
 
-function delmark!(marks, subject, m::Symbol)
-    ms = get(marks, subject, Symbol())
+function delmark!(marks::Marks, subject, m::Symbol)
+    soft = marks.soft
+    ms = get(soft, subject, Symbol())
     if ms isa Symbol
         if ms === m
-            marks[subject] = Symbol()
+            soft[subject] = Symbol()
         end
     else
         p = findfirst(==(m), ms)
@@ -82,8 +92,8 @@ function delmark!(marks, subject, m::Symbol)
     nothing
 end
 
-function hasmark(marks, subject, m::Symbol)
-    ms = get(marks, subject, Symbol())
+function hasmark(marks::Marks, subject, m::Symbol)
+    ms = get(marks.soft, subject, Symbol())
     if ms isa Symbol
         ms === m
     else

src/patterns.jl

@@ -144,11 +144,11 @@ matches(d::Depth, _, ts) = d.d == tsdepth(ts)
 matches(::Pass, subj::AbstractString, ts) = something(pastresult(ts.marks, subj), false)
 matches(::Fail, subj::AbstractString, ts) = !something(pastresult(ts.marks, subj), true)
 # TODO: test method below
-# instead of `isempty(ts.marks)`, a tighter test would be to check that no value in marks
+# instead of `isempty(ts.marks.soft)`, a tighter test would be to check that no value in marks
 # contains the pass/fail marks; but this would be a bit more expensive, as values have to be
 # iterated over
 matches(::Union{Pass,Fail}, ::Missing, ts) =
-    isempty(ts.marks) ? false : missing
+    isempty(ts.marks.soft) ? false : missing
 
 matches(i::Iter, subj, ts) =
     if ts.iter isa Int

src/testset.jl

@@ -14,7 +14,7 @@ using Distributed: myid, nworkers
 
 import InlineTest: @testset
 
-using ..ReTest: Pattern, matches, setresult!
+using ..ReTest: Pattern, Marks, matches, setresult!
 
 # mostly copied from Test stdlib
 # changed from Test: pass nothing as file in ip_has_file_and_func
@@ -65,7 +65,7 @@ mutable struct ReTestSet <: AbstractTestSet
     subject::String
     id::Int64
     overall::Bool # TODO: could be conveyed by having self.mod == ""
-    marks::Dict{String, Union{Symbol, Vector{Symbol}}} # used in matches()
+    marks::Marks # used in matches()
     iter::Int # used in matches()
     results::Vector
     n_passed::Int
@@ -77,8 +77,7 @@ end
 
 function ReTestSet(mod, desc::String, id::Integer=0;
                    overall=false, verbose=true, parent=nothing,
-                   marks=Dict{String, Union{Symbol, Vector{Symbol}}}(),
-                   iter=1)
+                   marks=Marks(), iter=1)
     parentsubj = parent === nothing ? "" : parent.subject
     subject = string(parentsubj, '/', desc)
     ReTestSet(mod, parent, desc, subject, id, overall, marks, iter, [],
@@ -474,13 +473,13 @@ end
 
 # non-inline testset with regex filtering support
 macro testset(mod::Module, isfinal::Bool, pat::Pattern, id::Int64, desc::Union{String,Expr},
-              options, marks::Dict, stats::Bool, chan, body)
+              options, marks::Marks, stats::Bool, chan, body)
     Testset.testset_beginend(mod, isfinal, pat, id, desc,
                              options, marks, stats, chan, body, __source__)
 end
 
 macro testset(mod::Module, isfinal::Bool, pat::Pattern, id::Int64, desc::Union{String,Expr},
-              options, marks::Dict, stats::Bool, chan, loops, body)
+              options, marks::Marks, stats::Bool, chan, loops, body)
     Testset.testset_forloop(mod, isfinal, pat, id, desc,
                             options, marks, stats, chan, loops, body, __source__)
 end
@@ -489,7 +488,7 @@ end
 Generate the code for a `@testset` with a `begin`/`end` argument
 """
 function testset_beginend(mod::Module, isfinal::Bool, pat::Pattern, id::Int64, desc, options,
-                          marks::Dict, stats::Bool, chan, tests, source)
+                          marks::Marks, stats::Bool, chan, tests, source)
     # Generate a block of code that initializes a new testset, adds
     # it to the task local storage, evaluates the test(s), before
     # finally removing the testset and giving it a chance to take
@@ -548,7 +547,7 @@ end
 Generate the code for a `@testset` with a `for` loop argument
 """
 function testset_forloop(mod::Module, isfinal::Bool, pat::Pattern, id::Int64,
-                         desc::Union{String,Expr}, options, marks::Dict, stats, chan,
+                         desc::Union{String,Expr}, options, marks::Marks, stats, chan,
                          loops, tests, source)
 
     desc = esc(desc)

test/test_patterns.jl

@@ -10,7 +10,7 @@ struct MockTestset
     parent
     iter
 
-    MockTestset() = new(rand(1:typemax(Int)), Dict(), nothing, 1)
+    MockTestset() = new(rand(1:typemax(Int)), ReTest.Marks(), nothing, 1)
 end
 
 ReTest.tsdepth(::MockTestset) = 1