test nested inits

Author: vchuravy

test/runtests.jl

@@ -1,23 +1,35 @@
 using Test
 
-function writepkg(name, precomp::Bool, submod::Bool)
+function writepkg(name, precomp::Bool, sub::Union{Symbol, Nothing})
     action = """
         global flag = true
     """
 
-    if submod
-        open("$(name)_submod.jl", "w") do io
-            println(io, """
-                export SubModule
-                module SubModule
-                    using Colors
-                    flag = true
-                end
-            """)
+    if sub === :module
+        sub_action = """
+            export SubModule
+            module SubModule
+                using Colors
+                flag = true
+            end
+        """
+    elseif sub === :file
+        sub_action = """
+            global subflag = false
+            @init begin
+                global subflag = true
+            end
+        """
+    end
+    @assert sub === :module || sub === :file || sub === nothing
+
+    if sub !== nothing
+        open("$(name)_sub.jl", "w") do io
+            println(io, sub_action)
         end
 
         action *= """
-            include("$(name)_submod.jl")
+            include("$(name)_sub.jl")
         """
     end
 
@@ -31,10 +43,8 @@ using Requires
 
 flag = false
 
-function __init__()
-    @require Colors="5ae59095-9a9b-59fe-a467-6f913c188581" begin
-        $(action)
-    end
+@init @require Colors="5ae59095-9a9b-59fe-a467-6f913c188581" begin
+    $(action)
 end
 
 end
@@ -48,22 +58,32 @@ end
             npcdir = joinpath("FooNPC", "src")
             mkpath(npcdir)
             cd(npcdir) do
-                writepkg("FooNPC", false, false)
+                writepkg("FooNPC", false, nothing)
             end
             npcdir = joinpath("FooPC", "src")
             mkpath(npcdir)
             cd(npcdir) do
-                writepkg("FooPC", true, false)
+                writepkg("FooPC", true, nothing)
+            end
+            npcdir = joinpath("FooSubModNPC", "src")
+            mkpath(npcdir)
+            cd(npcdir) do
+                writepkg("FooSubModNPC", false, :module)
             end
-            npcdir = joinpath("FooSubNPC", "src")
+            npcdir = joinpath("FooSubModPC", "src")
             mkpath(npcdir)
             cd(npcdir) do
-                writepkg("FooSubNPC", false, true)
+                writepkg("FooSubModPC", true, :module)
             end
-            npcdir = joinpath("FooSubPC", "src")
+            npcdir = joinpath("FooSubIncNPC", "src")
             mkpath(npcdir)
             cd(npcdir) do
-                writepkg("FooSubPC", true, true)
+                writepkg("FooSubIncNPC", false, :file)
+            end
+            npcdir = joinpath("FooSubIncPC", "src")
+            mkpath(npcdir)
+            cd(npcdir) do
+                writepkg("FooSubIncPC", true, :file)
             end
         end
         push!(LOAD_PATH, pkgsdir)
@@ -72,52 +92,73 @@ end
         @test !FooNPC.flag
         @eval using FooPC
         @test !FooPC.flag
-        @eval using FooSubNPC
-        @test !(:SubModule in names(FooSubNPC))
-        @eval using FooSubPC
-        @test !(:SubModule in names(FooSubPC))
+        @eval using FooSubModNPC
+        @test !(:SubModule in names(FooSubModNPC))
+        @eval using FooSubModPC
+        @test !(:SubModule in names(FooSubModPC))
+        @eval using FooSubIncPC
+        @test !isdefined(FooSubIncPC, :subflag)
+        @eval using FooSubIncNPC
+        @test !isdefined(FooSubIncNPC, :subflag)
 
         @eval using Colors
 
         @test FooNPC.flag
         @test FooPC.flag
-        @test :SubModule in names(FooSubNPC)
-        @test FooSubNPC.SubModule.flag
-        @test :SubModule in names(FooSubPC)
-        @test FooSubPC.SubModule.flag
+        @test :SubModule in names(FooSubModNPC)
+        @test FooSubModNPC.SubModule.flag
+        @test :SubModule in names(FooSubModPC)
+        @test FooSubModPC.SubModule.flag
+        @test_broken FooSubIncPC.subflag
+        @test_broken FooSubIncNPC.subflag
 
         cd(pkgsdir) do
             npcdir = joinpath("FooAfterNPC", "src")
             mkpath(npcdir)
             cd(npcdir) do
-                writepkg("FooAfterNPC", false, false)
+                writepkg("FooAfterNPC", false, nothing)
             end
             pcidr = joinpath("FooAfterPC", "src")
             mkpath(pcidr)
             cd(pcidr) do
-                writepkg("FooAfterPC", true, false)
+                writepkg("FooAfterPC", true, nothing)
+            end
+            sanpcdir = joinpath("FooSubModAfterNPC", "src")
+            mkpath(sanpcdir)
+            cd(sanpcdir) do
+                writepkg("FooSubModAfterNPC", false, :module)
             end
-            sanpcdir = joinpath("FooSubAfterNPC", "src")
+            sapcdir = joinpath("FooSubModAfterPC", "src")
+            mkpath(sapcdir)
+            cd(sapcdir) do
+                writepkg("FooSubModAfterPC", true, :module)
+            end
+            sanpcdir = joinpath("FooSubIncAfterNPC", "src")
             mkpath(sanpcdir)
             cd(sanpcdir) do
-                writepkg("FooSubAfterNPC", false, true)
+                writepkg("FooSubIncAfterNPC", false, :file)
             end
-            sapcdir = joinpath("FooSubAfterPC", "src")
+            sapcdir = joinpath("FooSubIncAfterPC", "src")
             mkpath(sapcdir)
             cd(sapcdir) do
-                writepkg("FooSubAfterPC", true, true)
+                writepkg("FooSubIncAfterPC", true, :file)
             end
         end
 
         @eval using FooAfterNPC
         @eval using FooAfterPC
-        @eval using FooSubAfterNPC
-        @eval using FooSubAfterPC
+        @eval using FooSubModAfterNPC
+        @eval using FooSubModAfterPC
+        @eval using FooSubIncAfterNPC
+        @eval using FooSubIncModAfterPC
         @test FooAfterNPC.flag
         @test FooAfterPC.flag
-        @test :SubModule in names(FooSubAfterNPC)
-        @test FooSubAfterNPC.SubModule.flag
-        @test :SubModule in names(FooSubAfterPC)
-        @test FooSubAfterPC.SubModule.flag
+        @test :SubModule in names(FooSubModAfterNPC)
+        @test FooSubModAfterNPC.SubModule.flag
+        @test :SubModule in names(FooSubModAfterPC)
+        @test FooSubModAfterPC.SubModule.flag
+        @test FooSubIncAfterPC.subflag
+        @test FooSubIncAfterNPC.subflag
+
     end
 end