Create new environment test flags, check async fail on windows

Author: Mark Kittisopikul

.travis.yml

@@ -20,12 +20,14 @@ jobs:
     env: JULIA_COPY_STACKS=0
   - julia: 1.0
     env: JULIA_COPY_STACKS=0
-  - os: windows
-    env: JULIA_COPY_STACKS=1
   allow_failures:
   - julia: nightly
+  - os: windows
+    env: JULIA_COPY_STACKS=1
   - os: linux
-    env: JULIA_COPY_STACKS=0
+    env: JULIA_COPY_STACKS=0 JAVACALL_FORCE_ASYNC_INIT=1
+  - os: linux
+    env: JULIA_COPY_STACKS=0 JAVACALL_FORCE_ASYNC_TEST=1
 
 branches:
   only:

src/JavaCall.jl

@@ -31,14 +31,17 @@ include("reflect.jl")
 
 function __init__()
     global JULIA_COPY_STACKS = get(ENV, "JULIA_COPY_STACKS", "") ∈ ("1", "yes")
-    if VERSION ≥ v"1.1-" && VERSION < v"1.3-"
-        @warn("JavaCall does not work correctly on Julia v$VERSION. \n" *
-                "Either use Julia v1.0.x, or v1.3.0 or higher.\n"*
-                "For 1.3 onwards, please also set the environment variable `JULIA_COPY_STACKS` to be `1` or `yes`")
-    end
-    if VERSION ≥ v"1.3-" && ! Sys.iswindows() && ! JULIA_COPY_STACKS
-        @warn("JavaCall needs the environment variable `JULIA_COPY_STACKS` to be `1` or `yes`.\n"*
-              "Calling the JVM may result in undefined behavior.")
+    if ! Sys.iswindows()
+        # On Windows, JULIA_COPY_STACKS is not needed and causes crash
+        if VERSION ≥ v"1.1-" && VERSION < v"1.3-"
+            @warn("JavaCall does not work correctly on Julia v$VERSION. \n" *
+                    "Either use Julia v1.0.x, or v1.3.0 or higher.\n"*
+                    "For 1.3 onwards, please also set the environment variable `JULIA_COPY_STACKS` to be `1` or `yes`")
+        end
+        if VERSION ≥ v"1.3-" && ! JULIA_COPY_STACKS
+            @warn("JavaCall needs the environment variable `JULIA_COPY_STACKS` to be `1` or `yes`.\n"*
+                  "Calling the JVM may result in undefined behavior.")
+        end
     end
     findjvm()
     global create = Libdl.dlsym(libjvm, :JNI_CreateJavaVM)

src/core.jl

@@ -122,7 +122,7 @@ end
 
 
 function jnew(T::Symbol, argtypes::Tuple, args...)
-    assertroottask()
+    assertroottask_or_goodenv()
     sig = method_signature(Nothing, argtypes...)
     jmethodId = ccall(jnifunc.GetMethodID, Ptr{Nothing},
                       (Ptr{JNIEnv}, Ptr{Nothing}, Ptr{UInt8}, Ptr{UInt8}), penv, metaclass(T),
@@ -136,7 +136,7 @@ end
 # Call static methods
 function jcall(typ::Type{JavaObject{T}}, method::AbstractString, rettype::Type, argtypes::Tuple,
                args... ) where T
-    assertroottask()
+    assertroottask_or_goodenv()
     sig = method_signature(rettype, argtypes...)
     jmethodId = ccall(jnifunc.GetStaticMethodID, Ptr{Nothing},
                       (Ptr{JNIEnv}, Ptr{Nothing}, Ptr{UInt8}, Ptr{UInt8}), penv, metaclass(T),
@@ -147,7 +147,7 @@ end
 
 # Call instance methods
 function jcall(obj::JavaObject, method::AbstractString, rettype::Type, argtypes::Tuple, args... )
-    assertroottask()
+    assertroottask_or_goodenv()
     sig = method_signature(rettype, argtypes...)
     jmethodId = ccall(jnifunc.GetMethodID, Ptr{Nothing},
                       (Ptr{JNIEnv}, Ptr{Nothing}, Ptr{UInt8}, Ptr{UInt8}), penv, metaclass(obj),
@@ -157,7 +157,7 @@ function jcall(obj::JavaObject, method::AbstractString, rettype::Type, argtypes:
 end
 
 function jfield(typ::Type{JavaObject{T}}, field::AbstractString, fieldType::Type) where T
-    assertroottask()
+    assertroottask_or_goodenv()
     jfieldID  = ccall(jnifunc.GetStaticFieldID, Ptr{Nothing},
                       (Ptr{JNIEnv}, Ptr{Nothing}, Ptr{UInt8}, Ptr{UInt8}), penv, metaclass(T),
                       String(field), signature(fieldType))
@@ -166,7 +166,7 @@ function jfield(typ::Type{JavaObject{T}}, field::AbstractString, fieldType::Type
 end
 
 function jfield(obj::JavaObject, field::AbstractString, fieldType::Type)
-    assertroottask()
+    assertroottask_or_goodenv()
     jfieldID  = ccall(jnifunc.GetFieldID, Ptr{Nothing},
                       (Ptr{JNIEnv}, Ptr{Nothing}, Ptr{UInt8}, Ptr{UInt8}), penv, metaclass(obj),
                       String(field), signature(fieldType))

src/jvm.jl

@@ -163,15 +163,20 @@ function init()
 end
 
 const ROOT_TASK_ERROR = JavaCallError(
-	"Either the environmental variable JULIA_COPY_STACKS must be 1 " *
-	"OR JavaCall must be used on the root Task.")
+    "Either the environmental variable JULIA_COPY_STACKS must be 1 " *
+    "OR JavaCall must be used on the root Task.")
+
+const JULIA_COPY_STACKS_ON_WINDOWS_ERROR = JavaCallError(
+    "JULIA_COPY_STACKS should not be set on Windows.")
 
 # JavaCall must run on the root Task or JULIA_COPY_STACKS is enabled
-isroottask() = JULIA_COPY_STACKS || Base.roottask === Base.current_task()
+isroottask() = Base.roottask === Base.current_task()
 @static if Sys.iswindows()
-    assertroottask() = nothing
+    isgoodenv() = ! JULIA_COPY_STACKS
+    assertroottask_or_goodenv() = isgoodenv() ? nothing : throw(JULIA_COPY_STACKS_ON_WINDOWS_ERROR)
 else
-    assertroottask() = isroottask() ? nothing : throw(ROOT_TASK_ERROR)
+    isgoodenv() = JULIA_COPY_STACKS || isroottask()
+    assertroottask_or_goodenv() = isgoodenv() ? nothing : throw(ROOT_TASK_ERROR)
 end
 
 isloaded() = isdefined(JavaCall, :jnifunc) && isdefined(JavaCall, :penv) && penv != C_NULL
@@ -182,7 +187,7 @@ assertnotloaded() = isloaded() ? throw(JavaCallError("JVM already initialised"))
 # Pointer to pointer to pointer to pointer alert! Hurrah for unsafe load
 function init(opts)
     assertnotloaded()
-    assertroottask()
+    assertroottask_or_goodenv()
     opt = [JavaVMOption(pointer(x), C_NULL) for x in opts]
     ppjvm = Array{Ptr{JavaVM}}(undef, 1)
     ppenv = Array{Ptr{JNIEnv}}(undef, 1)
@@ -259,7 +264,7 @@ function destroy()
     if (!isdefined(JavaCall, :penv) || penv == C_NULL)
         throw(JavaCallError("Called destroy without initialising Java VM"))
     end
-    assertroottask()
+    assertroottask_or_goodenv()
     res = ccall(jvmfunc.DestroyJavaVM, Cint, (Ptr{Nothing},), pjvm)
     res < 0 && throw(JavaCallError("Unable to destroy Java VM"))
     global penv=C_NULL; global pjvm=C_NULL;

test/runtests.jl

@@ -12,9 +12,11 @@ macro syncasync(x)
     :( (@sync @async eval($x)).result ) |> esc
 end
 
+JAVACALL_FORCE_ASYNC_INIT = get(ENV,"JAVACALL_FORCE_ASYNC_INIT","") ∈ ("1","yes")
+JAVACALL_FORCE_ASYNC_TEST = get(ENV,"JAVACALL_FORCE_ASYNC_TEST","") ∈ ("1","yes")
 
 @testset "initialization" begin
-    if JavaCall.JULIA_COPY_STACKS
+    if JavaCall.JULIA_COPY_STACKS || JAVACALL_FORCE_ASYNC_INIT
         @testasync JavaCall.init(["-Djava.class.path=$(@__DIR__)"])==nothing
     else
         @test JavaCall.init(["-Djava.class.path=$(@__DIR__)"])==nothing
@@ -63,7 +65,7 @@ end
 
 @testset "static_method_call_async_1" begin
     jlm = @jimport "java.lang.Math"
-    if JavaCall.JULIA_COPY_STACKS || Sys.iswindows()
+    if JAVACALL_FORCE_ASYNC_TEST || JavaCall.JULIA_COPY_STACKS || Sys.iswindows()
         @testasync 1.0 ≈ jcall(jlm, "sin", jdouble, (jdouble,), pi/2)
         @testasync 1.0 ≈ jcall(jlm, "min", jdouble, (jdouble,jdouble), 1,2)
         @testasync 1 == jcall(jlm, "abs", jint, (jint,), -1)
@@ -169,8 +171,8 @@ end
 # However, since Java and Julia memory are not linked, and manual gc() is required.
 gc()
 for i in 1:100000
-	a=JString("A"^10000); #deleteref(a);
-	if (i%10000 == 0); gc(); end
+    a=JString("A"^10000); #deleteref(a);
+    if (i%10000 == 0); gc(); end
 end
 
 @testset "sinx_1" begin
@@ -254,12 +256,18 @@ end
     @test isa(narrow(o), JString)
 end
 
-@testset "isroottask_1" begin
+@testset "roottask_and_env_1" begin
     @test JavaCall.isroottask()
-    @testasync JavaCall.JULIA_COPY_STACKS || ! JavaCall.isroottask()
-    if ! JavaCall.JULIA_COPY_STACKS && ! Sys.iswindows()
-        @test_throws CompositeException @syncasync JavaCall.assertroottask()
-        @warn "Ran tests for root Task only. REPL and @async are not expected to work with JavaCall. Set JULIA_COPY_STACKS=1 in the environment to test @async function."
+    @testasync ! JavaCall.isroottask()
+    @test JavaCall.isgoodenv()
+    if JAVACALL_FORCE_ASYNC_TEST || JavaCall.JULIA_COPY_STACKS || Sys.iswindows()
+        @testasync JavaCall.isgoodenv()
+    end
+    if JAVACALL_FORCE_ASYNC_TEST || ! JavaCall.JULIA_COPY_STACKS
+        @test_throws CompositeException @syncasync JavaCall.assertroottask_or_goodenv()
+        @warn "Ran tests for root Task only." *
+            " REPL and @async are not expected to work with JavaCall without JULIA_COPY_STACKS=1." *
+            " Set JULIA_COPY_STACKS=1 in the environment to test @async function."
     end
 end