rename at-addtest to at-testset (suggested by at-oxinabox)

Author: rfourquet

README.md

@@ -5,7 +5,10 @@ This is useful when one likes to have definitions of methods and corresponding t
 This is also useful for code which is not (yet) organized as a package, and where one doesn't want to maintain
 a separate set of files for tests.
 
-The `@addtest` macro can be used as a direct replacement for `@testset`, and `runtests()` has to
-be called for the tests to be executed. See the docstrings for more details.
+The exported `InlineTest.@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 for more details.
 When used in a package `MyPackage`, the following can be added to its `test/runtests.jl` file
-in order to have `@addtest` tests run as part of the usual package testing process: `runtests(MyPackage)`
+in order to have `InlineTest.@testset` tests run as part of the usual package testing process:
+`runtests(MyPackage)` (depending on whether `Test` is imported in the test file -- in which case
+there would be a name resolution conflict for `@testset` --  you might bring
+`runtests` in scope either with `using InlineTest` or `using InlineTest: runtests`).

src/InlineTest.jl

@@ -1,9 +1,8 @@
 module InlineTest
 
-export @addtest, runtests, @testset, @test, @test_throws
+export runtests, @testset, @test, @test_throws, Test
 
-using Test: @test, @test_throws, @testset
-import Test
+using Test: Test, @test, @test_throws
 
 const INLINE_TEST = Ref{Symbol}(:__INLINE_TEST__)
 
@@ -17,40 +16,50 @@ function tests(m)
     getfield(m, inline_test)
 end
 
+replacetestset(x) = x
+
+# replace unqualified `@testset` by Test.@testset
+function replacetestset(x::Expr)
+    x.head === :macrocall && x.args[1] === Symbol("@testset") ?
+        Expr(:macrocall, Expr(:., :Test, QuoteNode(Symbol("@testset"))), map(replacetestset, x.args[2:end])...) :
+        Expr(x.head, map(replacetestset, x.args)...)
+end
+
 function addtest(args::Tuple, m::Module)
-    push!(tests(m), :(@testset($(args...))))
+    args = map(replacetestset, args)
+    push!(tests(m), :(InlineTest.Test.@testset($(args...))))
     nothing
 end
 
 """
-    @addtest args...
+    @testset args...
 
-Similar to `@testset args...`, but the contained tests are not run immediately,
+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 `@addtest` should appear only at the top level, and not be nested
-(`@testset` can be nested within `@addtest`).
-Internally, `@addtest` is converted to `@testset` at execution time.
+Invocations of `@testset` can be nested, but qualified invocations of
+`InlineTest.@testset` can't.
+Internally, `@testset` invocations are converted to `Test.@testset` at execution time.
 """
-macro addtest(args...)
+macro testset(args...)
     Expr(:call, :addtest, args, __module__)
 end
 
 """
     runtests([m::Module]; [wrap::Bool])
 
-Run all the tests declared in `@addtest` blocks, within `m` if specified,
+Run all the tests declared in `@testset` blocks, within `m` if specified,
 or within all currently loaded modules otherwise.
 The `wrap` keyword specifies whether the collection of `@testset` blocks derived
-from `@addtest` declarations should be grouped within a top-level `@testset`.
+from `@testset` declarations should be grouped within a top-level `@testset`.
 The default is `wrap=false` when `m` is specified, `true` otherwise.
 
-Note: this function executes each `@testset` block using `eval` *within* the module
-in which the corresponding `@addtest` block was written (e.g. `m`, when specified).
+Note: this function executes each (top-level) `@testset` block using `eval` *within* the module
+in which it was written (e.g. `m`, when specified).
 """
 function runtests(m::Module; wrap::Bool=false)
     Core.eval(m,
               if wrap
-                  :(@testset $("Tests for module $m") begin
+                  :(InlineTest.Test.@testset $("Tests for module $m") begin
                     $(tests(m)...)
                     end)
               else
@@ -71,13 +80,13 @@ end
 module InlineTestTest
 
 using ..InlineTest
-@addtest "test Test in sub-module" begin
+@testset "test Test in sub-module" begin
     @test 1 == 1
 end
 
 end # module InlineTestTest
 
-@addtest "self test" begin
+@testset "self test" begin
     @assert typeof(@__MODULE__) == Module
     @test 1 != 2
     runtests(InlineTestTest)