filtering: add symbol (label) patterns

Author: rfourquet

src/ReTest.jl

@@ -188,6 +188,15 @@ function delmark!(marks, subject, m::Symbol)
     nothing
 end
 
+function hasmark(marks, subject, m::Symbol)
+    ms = get(marks, subject, Symbol())
+    if ms isa Symbol
+        ms === m
+    else
+        m ∈ ms
+    end
+end
+
 
 struct _Invalid
     global const invalid = _Invalid.instance
@@ -679,10 +688,11 @@ Moreover if a testset is run, its enclosing testset, if any, also has to run
 (although not necessarily exhaustively, i.e. other nested testsets
 might be filtered out).
 
-A `pattern` can be a string, a `Regex`, an integer, an array or a tuple.
+A `pattern` can be a string, a `Regex`, an integer, a symbol, an array or a tuple.
 For a testset to "match" an array, it must match at least one of its elements (disjunction).
 To match a tuple, it must match all of its elements (conjunction).
 To match an integer, its ID must be equal to this integer (cf. the `id` keyword).
+To match a symbol, it must be tagged with that symbol (label).
 
 A pattern can also be the "negation" of a pattern, via the [`not`](@ref) function,
 which allows to exclude testsets from being run.
@@ -811,6 +821,10 @@ function retest(@nospecialize(args::ArgType...);
     if !dry && !isempty(tag)
         @warn "tag keyword: labels can be added only in dry mode"
     end
+    for label in tag
+        startswith(String(label), '_') &&
+            throw(ArgumentError("tag keyword: labels can't start with an underscore"))
+    end
 
     for imod in eachindex(modules)
         mod, pat = modules[imod]
@@ -1212,7 +1226,9 @@ function update_keywords(@nospecialize(args), dry, stats, shuffle, group, verbos
                          recursive, id, strict, dup, static, marks, spin)
     for arg in args
         if arg isa Symbol
-            for c in string(arg)
+            sarg = String(arg)
+            startswith(sarg, '_') || continue
+            for c in sarg[2:end]
                 c == 'v' && continue # "verbose" ignored, we care only about the value
                 val = islowercase(c)
                 c = lowercase(c)
@@ -1300,7 +1316,7 @@ function process_args(@nospecialize(args);
             push!(pat.xs, make_pattern(last(arg)))
             mod ∉ modules && push!(modules, mod)
             load_testmod(mod)
-        elseif arg isa Symbol
+        elseif arg isa Symbol && startswith(String(arg), '_')
             # ignored, already processed in update_keywords
         else
             push!(patterns, make_pattern(arg))

src/patterns.jl

@@ -1,4 +1,4 @@
-const PatternX = Union{Pattern, Regex, Integer}
+const PatternX = Union{Pattern, Regex, Integer, Symbol}
 
 ## Patterns
 
@@ -89,6 +89,7 @@ alwaysmatches(::Not, _) = false
 alwaysmatches(::Interpolated, _) = false
 alwaysmatches(rx::Regex, _) = isempty(rx.pattern)
 alwaysmatches(id::Integer, _) = false
+alwaysmatches(label::Symbol, _) = false
 alwaysmatches(pat::Reachable, d) = alwaysmatches(pat.x, d)
 alwaysmatches(dep::Depth, d) = dep.d == d
 alwaysmatches(::Pass, _) = false
@@ -116,6 +117,11 @@ matches(pat::Integer, _, ts) =
         pat == ts.id :
         pat != -ts.id
 
+matches(label::Symbol, subj::AbstractString, ts) = hasmark(ts.marks, subj, label)
+matches(label::Symbol, subj::Missing, ts) = missing
+# TODO: optimize by recording possible labels for missing, to allow returning false
+# in some cases
+
 function matches(pat::Reachable, desc, ts)
     if desc !== missing
         desc = SubString(desc)

test/runtests.jl

@@ -948,14 +948,14 @@ module Marks
 using ReTest, ..Trace
 
 @testset "a" begin
-    @test true
+    trace("a")
     @testset "b" begin end # no test, counts as pass
     @testset "c" begin
-        @test true
+        trace("c")
     end
     x = 1
     @testset "d$x" begin
-        @test true
+        trace("d$x")
     end
     @testset "e" begin
         @test false
@@ -1129,6 +1129,8 @@ x ⋯
     retest(Marks, r"a$", dry=false)
     retest(Marks, r"a$", dry=true, tag=[:a3 :a4])
     retest(Marks, r"a$", dry=true, tag=(:a5, :a6))
+    @test_throws ArgumentError retest(Marks, r"a$", dry=true, tag=:_underscored)
+
     check(Marks, "-l", -4, dry=true, verbose=9, id=false, marks=true, [], output="""
 a a1 a2 a3 a4 a5 a6 ✔
   b
@@ -1146,6 +1148,35 @@ x
     z3
     z4
 """)
+    check(Marks, "a", "-l", -4, :a2, dry=true, verbose=9, id=false, marks=true, [],
+          output="a a1 a2 a3 a4 a5 a6 ✔")
+    check(Marks, "a", "-l", -4, :a2, dry=false, verbose=9, id=false, marks=true, ["a"])
+    if VERSION >= v"1.3"
+        check(Marks, "-l", -4, not(reachable(:a1)), dry=true, verbose=9, id=false,
+              marks=true, [], output="""
+x
+  y1 ylabel
+    z1 ylabel
+    z2 ylabel
+    z3 ylabel
+    z4 ylabel
+  y2
+    z1
+    z2
+    z3
+    z4
+""")
+    check(Marks, "-l", -4, reachable("x"), not(:ylabel), dry=true, verbose=9, id=false,
+          marks=true, [], output="""
+x
+  y1 ylabel
+  y2
+    z1
+    z2
+    z3
+    z4
+""")
+    end
 end
 
 

test/test_patterns.jl

@@ -15,14 +15,15 @@ end
 
 ReTest.tsdepth(::MockTestset) = 1
 
-const basic_patterns = [and(), or(), not(0), interpolated, 0, r"", depth(2), pass, fail, iter(1)]
+const basic_patterns = [and(), or(), not(0), interpolated, 0, r"", :label,
+                        depth(2), pass, fail, iter(1)]
 VERSION >= v"1.3" && push!(basic_patterns, reachable(1))
 
 @testset "patterns: ==" begin
     for a = basic_patterns, b = basic_patterns
         if a === b
             @test a == b
-            if !(a isa Regex || a isa Integer)
+            if !(a isa Regex || a isa Integer || a isa Symbol)
                 @test -a == not(a)
             end
         else