rename package: InlineTest -> ReTest

Author: rfourquet

LICENSE.md

@@ -1,4 +1,4 @@
-The InlineTest.jl package is licensed under the MIT "Expat" License:
+The ReTest.jl package is licensed under the MIT "Expat" License:
 
 > Copyright (c) 2020: Rafael Fourquet.
 >

Project.toml

@@ -1,5 +1,5 @@
-name = "InlineTest"
-uuid = "bd334432-b1e7-49c7-a2dc-dd9149e4ebd6"
+name = "ReTest"
+uuid = "e0db7c4e-2690-44b9-bad6-7687da720f89"
 authors = ["Rafael Fourquet <[email protected]>"]
 version = "0.1.0"
 

README.md

@@ -1,4 +1,4 @@
-# InlineTest
+# ReTest
 
 This package allows:
 
@@ -21,11 +21,11 @@ This package allows:
    exists in the Julia repository to implement regex-filtering for
    `Test.@testset`.
 
-The exported `InlineTest.@testset` macro can be used as a direct replacement for
+The exported `ReTest.@testset` macro can be used as a direct replacement for
 `Test.@testset`, and `runtests()` has to be called for the tests to be executed.
-See the docstrings (reproduced below) for more details. Moreover, `InlineTest`
+See the docstrings (reproduced below) for more details. Moreover, `ReTest`
 re-exports (almost) all exported symbols from `Test`, so there should not be any
-need to import `Test` together with `InlineTest`.
+need to import `Test` together with `ReTest`.
 
 ### `runtests` docstring
 
@@ -68,7 +68,7 @@ module in which it was written (e.g. `m`, when specified).
 
 ### Caveats
 
-`InlineTest.@testset` comes with a couple of caveats/limitations:
+`ReTest.@testset` comes with a couple of caveats/limitations:
 
 * Toplevel testsets (which are not nested within other testsets), when run, are
   `eval`ed at the toplevel of their parent module, which means that they can't
@@ -87,16 +87,16 @@ module in which it was written (e.g. `m`, when specified).
 * Testsets can not be "custom testsets" (cf. `Test` documentation; this should
   be easy to support).
 
-* Nested testsets can't be "qualified" (i.e. written as `InlineTest.@testset`).
+* Nested testsets can't be "qualified" (i.e. written as `ReTest.@testset`).
 
 * Regex filtering logic might improve in future versions, which means that with
   the same regex, less tests might be run (or more!). See `runtests`'s docstring
   to know what testsets are guaranteed to run.
 
-### Switching from `Test` to `InlineTest`
+### Switching from `Test` to `ReTest`
 
 When used in a package `MyPackage`, the test code can be organized as follows:
-1. replace `using Test` by `using InlineTest` in the "runtests.jl" file
+1. replace `using Test` by `using ReTest` in the "runtests.jl" file
 2. wrap the whole content of "runtests.jl" within a module named `MyPackageTests`
 3. rename "runtests.jl" to "tests.jl"
 4. create "runtests.jl" with the following content:
@@ -105,7 +105,7 @@ When used in a package `MyPackage`, the test code can be organized as follows:
 This means that running "runtests.jl" will have the same net effect as before.
 The "tests.jl" file can now be `include`d in your REPL session (`include("tests.jl")`),
 and you can run all or some of its tests
-(e.g. `using InlineTest; runtests(MyPackageTests, "addition")`).
+(e.g. `using ReTest; runtests(MyPackageTests, "addition")`).
 Wrapping the tests in `MyPackageTests` allows to not pollute `Main`, it keeps the tests
 of different packages separated, but more importantly, you can modify "tests.jl" and
 re-include it to have the corresponding tests updated (otherwise, without
@@ -114,12 +114,12 @@ without removing the old ones).
 
 ### Toplevel testsets
 
-In `InlineTest`, toplevel testsets are special, as already mentioned. The fact
+In `ReTest`, toplevel testsets are special, as already mentioned. The fact
 that they are `eval`ed at the module's toplevel also means that we can actually
 filter them out (if a filtering pattern is given to `runtests`) "statically",
 i.e. by introspection, we can figure out whether they should be run before
 having to `eval` the corresponding code. This is a big win, in particular for
-`testsets-for`, which are expensive to compile. This allows `InlineTest` to
+`testsets-for`, which are expensive to compile. This allows `ReTest` to
 compete with the good-old manual way of copy-pasting the wanted `@testset` into
 the REPL (without this trick, all the testsets would have to be `eval`ed, even
 when they don't run any code, and this can take some time for large test

src/InlineTest.jl renamed to src/ReTest.jl

@@ -1,4 +1,4 @@
-module InlineTest
+module ReTest
 
 export runtests, @testset
 
@@ -36,7 +36,7 @@ struct TestsetExpr
 end
 
 function tests(m::Module)
-    inline_test::Symbol = m ∈ (InlineTest, InlineTest.InlineTestTest) ? :__INLINE_TEST__ : INLINE_TEST[]
+    inline_test::Symbol = m ∈ (ReTest, ReTest.ReTestTest) ? :__INLINE_TEST__ : INLINE_TEST[]
     if !isdefined(m, inline_test)
         @eval m $inline_test = []
         push!(TESTED_MODULES, m)
@@ -57,7 +57,7 @@ function replacetestset(x::Expr)
         final = !any(last, body)
         (Expr(:let,
               :($(Testset.FINAL[]) = $final),
-              Expr(:macrocall, Expr(:., :InlineTest, QuoteNode(Symbol("@testsetr"))),
+              Expr(:macrocall, Expr(:., :ReTest, QuoteNode(Symbol("@testsetr"))),
                    map(first, body)...)),
          final,
          true)
@@ -103,7 +103,7 @@ end
 Similar to `Test.@testset args...`, but the contained tests are not run immediately,
 and are instead stored for later execution, triggered by `runtests()`.
 Invocations of `@testset` can be nested, but qualified invocations of
-`InlineTest.@testset` can't.
+`ReTest.@testset` can't.
 Internally, `@testset` invocations are converted to `Test.@testset` at execution time.
 """
 macro testset(args...)
@@ -157,7 +157,7 @@ function runtests(m::Module, pattern::Union{AbstractString,Regex} = r""; wrap::B
                                                    string('/', desc, final ? "" : "/"))
 
     if wrap
-        Core.eval(m, :(InlineTest.Test.@testset $("Tests for module $m") begin
+        Core.eval(m, :(ReTest.Test.@testset $("Tests for module $m") begin
                            $(map(ts -> wrap_ts(partial, regex, ts), tests(m))...)
                        end))
     else
@@ -206,7 +206,7 @@ function wrap_ts(partial, regex, ts::TestsetExpr, loopvals=nothing)
             let $(Testset.REGEX[]) = ($partial, $regex),
                 $(Testset.FINAL[]) = $(ts.final)
 
-                InlineTest.@testsetr $(ts.desc) for $(ts.loops.args[1]) in $loopvals
+                ReTest.@testsetr $(ts.desc) for $(ts.loops.args[1]) in $loopvals
                     $(ts.body)
                 end
             end
@@ -218,10 +218,10 @@ function runtests(pattern::Union{AbstractString,Regex} = r""; wrap::Bool=true)
     for mods in (values(Base.loaded_modules), TESTED_MODULES)
         # TESTED_MODULES is not up-to-date w.r.t. package modules which have
         # precompilation, so we have to also look in Base.loaded_modules
-        # TODO: look recursively in "loaded modules" which use InlineTest for sub-modules
+        # TODO: look recursively in "loaded modules" which use ReTest for sub-modules
         foreach(mods) do m
             if isdefined(m, INLINE_TEST[])
-                # will automatically skip InlineTest and InlineTest.InlineTestTest
+                # will automatically skip ReTest and ReTest.ReTestTest
                 runtests(m, pattern, wrap=wrap)
             end
         end
@@ -236,20 +236,20 @@ function partialize(r::Regex)
     end
 end
 
-module InlineTestTest
+module ReTestTest
 
-using ..InlineTest
+using ..ReTest
 @testset "test Test in sub-module" begin
     @test 1 == 1
 end
 
-end # module InlineTestTest
+end # module ReTestTest
 
 @testset "self test" begin
     @assert typeof(@__MODULE__) == Module
     @test 1 != 2
-    runtests(InlineTestTest)
-    runtests(InlineTestTest, wrap=true)
+    runtests(ReTestTest)
+    runtests(ReTestTest, wrap=true)
 end
 
-end # module InlineTest
+end # module ReTest

src/testset.jl

@@ -8,7 +8,7 @@ using Test: DefaultTestSet, Error, Test, _check_testset, finish, get_testset,
 using Random: Random, default_rng
 
 const REGEX = Ref{Symbol}()
-const FINAL = Ref{Symbol}(:__FINAL__) # must have a value at compile time for InlineTestTest
+const FINAL = Ref{Symbol}(:__FINAL__) # must have a value at compile time for ReTestTest
 
 function __init__()
     REGEX[] = gensym()

test/runtests.jl

@@ -1,7 +1,7 @@
-using InlineTest
+using ReTest
 
 module M
-using InlineTest
+using ReTest
 
 RUN = []
 
@@ -78,7 +78,7 @@ runtests(M, wrap=true) # TODO: more precise tests
 runtests(M, wrap=false)
 
 module N
-using InlineTest
+using ReTest
 
 RUN = []
 
@@ -122,7 +122,7 @@ N.check("^/i/j0", ["i"])
 N.check("^/i/l10", ["i"])
 
 module P
-using InlineTest
+using ReTest
 
 RUN = []
 
@@ -149,7 +149,7 @@ function check(rx, list)
 end
 end
 
-import .P # test InlineTest's wrapping of non-regex patterns
+import .P # test ReTest's wrapping of non-regex patterns
 P.check("b", ["a", "b", "b|c"]) # an implicit prefix r".*" is added
 P.check("b|c", ["a", "b|c"]) # "b" is not matched