retest: put kwargs default values in a global NamedTuple

These defaults were used in three different places, so a central
places storing the default values helps with maintaining consistency.
Also this is a first step towards user-overridable defaults.

Author: rfourquet

src/ReTest.jl

@@ -478,6 +478,26 @@ const ArgType = Union{Module,PatternX,AbstractString,AbstractArray,Tuple,Symbol,
                       Pair{Module,
                            <:Union{PatternX,AbstractString,AbstractArray,Tuple}}}
 
+const retest_defaults = (
+    dry       = false,
+    stats     = false,
+    shuffle   = false,
+    group     = true,
+    verbose   = true,
+    recursive = true,
+    id        = nothing,
+    strict    = true,
+    dup       = false,
+    static    = nothing,
+    load      = false,
+    seed      = false,
+    marks     = true,
+    spin      = true,
+)
+
+def(kw::Symbol) = retest_defaults[kw]
+
+
 """
     retest(mod..., pattern...;
            dry::Bool=false, stats::Bool=false, verbose::Real=true,
@@ -608,20 +628,21 @@ i.e. this is equivalent to specifying `sub => (pattern, subpat)`.
     module in which it was written (e.g. `mod`, when specified).
 """
 function retest(@nospecialize(args::ArgType...);
-                dry::Bool=false,
-                stats::Bool=false,
-                shuffle::Bool=false,
-                group::Bool=true,
-                verbose::Real=true, # should be @nospecialize, but not supported on old Julia
-                recursive::Bool=true,
-                id::Maybe{Bool}=nothing,
-                strict::Bool=true,
-                dup::Bool=false,
-                static::Maybe{Bool}=nothing,
-                load::Bool=false,
-                seed::Integer=false,
-                marks::Bool=true,
-                spin::Bool=true,
+                dry::Bool           = def(:dry),
+                stats::Bool         = def(:stats),
+                shuffle::Bool       = def(:shuffle),
+                group::Bool         = def(:group),
+                # should be @nospecialize, but not supported on old Julia
+                verbose::Real       = def(:verbose),
+                recursive::Bool     = def(:recursive),
+                id::Maybe{Bool}     = def(:id),
+                strict::Bool        = def(:strict),
+                dup::Bool           = def(:dup),
+                static::Maybe{Bool} = def(:static),
+                load::Bool          = def(:load),
+                seed::Integer       = def(:seed),
+                marks::Bool         = def(:marks),
+                spin::Bool          = def(:spin),
                 )
 
     dry, stats, shuffle, group, verbose, recursive, id, strict, dup, static, marks, spin =
@@ -1107,8 +1128,8 @@ end
 function process_args(@nospecialize(args);
                       # defaults for keywords are added just for process_args to be more
                       # easily called from test code
-                      # TODO: set defaults in global variables to help stay in sync?
-                      verbose=true, shuffle=false, recursive=true, load::Bool=false)
+                      verbose=def(:verbose), shuffle=def(:shuffle),
+                      recursive=def(:recursive), load::Bool=def(:load))
     ########## process args
     patterns = PatternX[] # list of standalone patterns
     modpats = Dict{Module,Any}() # pairs module => pattern

test/setup.jl

@@ -13,9 +13,14 @@ end
 end
 
 # NOTE: all keywords have the same defaults as `retest`, except `marks`
+# Also, not sure why ReTest.def has to be qualified, when we just import def from ReTest
+# in this module and call it unqualified, then `def` is said to not exist when running
+# the test suite, from within a call to @chapter
 function check(x...; runtests=false, output::Union{Nothing,String}=nothing,
-               verbose=true, stats=false, dry=false, strict::Bool=true,
-               recursive=true, static=nothing, id=nothing, load=false, marks::Bool=false)
+               verbose=ReTest.def(:verbose), stats=ReTest.def(:stats), dry=ReTest.def(:dry),
+               strict::Bool=ReTest.def(:strict), recursive=ReTest.def(:recursive),
+               static=ReTest.def(:static), id=ReTest.def(:id), load=ReTest.def(:load),
+               marks::Bool=false)
     @assert !(runtests & (output !== nothing)) "unimplemented"
     args = x[1:end-1]
     expected = x[end]