Improved tests of scala port and java loader.

Author: viferga

source/loaders/java_loader/source/java_loader_impl.cpp

@@ -129,7 +129,7 @@ loader_impl_data java_loader_impl_initialize(loader_impl impl, configuration con
 	if (java_impl != nullptr)
 	{
 		#define TEST_CLASS_PATH \
-			"ADD HERE YOUR CLASSPATH"
+			"$(sbt 'export test:fullClasspath')"
 
 		static const size_t options_size = 2;
 
@@ -186,7 +186,8 @@ loader_handle java_loader_impl_load_from_file(loader_impl impl, const loader_nam
 			std::cout << "ffffffffffffffffffffffffffff" << std::endl;
 		}
 
-		jclass cls2 = java_impl->env->FindClass("metacall/MetaCallSpecRunner");
+		// jclass cls2 = java_impl->env->FindClass("metacall/MetaCallSpecRunner");
+		jclass cls2 = java_impl->env->FindClass("metacall/CallerSpecRunner");
 
 		if (cls2 == nullptr)
 		{

source/ports/scala_port/src/main/scala/Caller.scala

@@ -6,6 +6,7 @@ import scala.concurrent.ExecutionContext
 
 import com.sun.jna._, ptr.PointerByReference
 import java.util.concurrent.{ConcurrentLinkedQueue, ConcurrentHashMap}
+import java.util.concurrent.locks.{ReentrantLock}
 import java.util.concurrent.atomic.{AtomicBoolean, AtomicInteger}
 
 /** `Caller` creates a new thread on which:
@@ -41,32 +42,46 @@ object Caller {
     if (!runningInMetacall)
       Bindings.instance.metacall_initialize()
 
-    while (!closed.get) try {
+    while (!closed.get) {
       if (!scriptsQueue.isEmpty()) {
-        val LoadCommand(namespace, runtime, paths) = scriptsQueue.poll()
-        val handleRef = namespace.map(_ => new PointerByReference())
-        Loader.loadFilesUnsafe(runtime, paths, handleRef)
-        handleRef.zip(namespace) match {
-          case Some((handleRef, namespace)) =>
-            namespaceHandles.put(
-              namespace,
-              handleRef
-            )
-          case None => ()
+        try {
+          scriptsLock.lock()
+          val LoadCommand(namespace, runtime, paths) = scriptsQueue.poll()
+          val handleRef = namespace.map(_ => new PointerByReference())
+          Loader.loadFilesUnsafe(runtime, paths, handleRef)
+          handleRef.zip(namespace) match {
+            case Some((handleRef, namespace)) =>
+              namespaceHandles.put(
+                namespace,
+                handleRef
+              )
+            case None => ()
+          }
+          // TODO: We may need to set up the result or the error in a monad
+        } catch {
+          // TODO: We may need to set up the result or the error in a monad
+          case e: Throwable => Console.err.println(e)
+        } finally {
+          scriptsReady.signal()
+          scriptsLock.unlock()
         }
       } else if (!callQueue.isEmpty()) {
-        val UniqueCall(Call(namespace, fnName, args), id) = callQueue.poll()
-        val result = callUnsafe(namespace, fnName, args)
-        callResultMap.put(id, result)
+        try {
+          val UniqueCall(Call(namespace, fnName, args), id) = callQueue.poll()
+          val result = callUnsafe(namespace, fnName, args)
+          callResultMap.put(id, result)
+        } catch {
+          case e: Throwable => Console.err.println(e)
+        }
       }
-    } catch {
-      case e: Throwable => Console.err.println(e)
     }
 
     if (!runningInMetacall)
       Bindings.instance.metacall_destroy()
   }
 
+  private val scriptsLock = new ReentrantLock()
+  private val scriptsReady = scriptsLock.newCondition()
   private val closed = new AtomicBoolean(false)
   private val callQueue = new ConcurrentLinkedQueue[UniqueCall]()
   private val callResultMap = new ConcurrentHashMap[Int, Value]()
@@ -90,7 +105,13 @@ object Caller {
     }
 
     scriptsQueue.add(LoadCommand(namespace, runtime, filePaths))
-    while (!scriptsQueue.isEmpty()) ()
+
+    scriptsLock.lock()
+
+    while (!scriptsQueue.isEmpty())
+      scriptsReady.await()
+
+    scriptsLock.unlock()
   }
 
   def loadFile(
@@ -106,10 +127,7 @@ object Caller {
     loadFile(runtime, filePath, None)
 
   def start(): Unit = {
-    if (!runningInMetacall)
-      new Thread(() => callLoop()).start()
-    else
-      callLoop()
+    new Thread(() => callLoop()).start()
   }
 
   def destroy(): Unit = closed.set(true)

source/ports/scala_port/src/test/scala/CallerSpec.scala

@@ -3,10 +3,14 @@ package metacall
 import metacall.instances._
 import org.scalatest.flatspec.AnyFlatSpec
 
+class CallerSpecRunner {
+  def run() = {
+    println("Executing CallerSpec Tests")
+    (new CallerSpec()).execute()
+  }
+}
+
 class CallerSpec extends AnyFlatSpec {
-  // TODO: This won't work with NodeJS, it is not tolerant a reinitialization.
-  //       Probably we should split this into two tests, one for the caller (event loop based),
-  //       and another for MetaCall without event loop. So each test suite runs in a different process.
   "Caller" should "start successfully" in {
     Caller.start()
   }

source/ports/scala_port/src/test/scala/MetaCallSpec.scala

@@ -21,16 +21,21 @@ class MetaCallSpec extends AnyFlatSpec {
   "MetaCall" should "initialize successfully" in {
     // TODO: Remove this if we drop support for executing Scala outside of MetaCall
     // TODO: Create a destroy method wrapping this functionality
-    if (System.getProperty("java.polyglot.name") != "metacall") {
+    if (System.getProperty("metacall.polyglot.name") != "core") {
       assert(
         metacall.metacall_initialize() == 0,
         "MetaCall was not successfully initialized"
       )
     }
   }
 
-  /*
   "MetaCall" should "load node script successsfully" in {
+    // NodeJS requires to set the library path environment variable
+    assert(
+      sys.env("LOADER_LIBRARY_PATH") != "",
+      "For running NodeJS tests you must define the loader library path"
+    )
+
     val scriptPaths = Array(
       Paths.get("./src/test/scala/scripts/main.js").toAbsolutePath.toString()
     )
@@ -46,7 +51,6 @@ class MetaCallSpec extends AnyFlatSpec {
       s"MetaCall failed to load the script with code $retCode"
     )
   }
-   */
 
   "MetaCall" should "load python script successsfully" in {
     val scriptPaths = Array(
@@ -83,7 +87,7 @@ class MetaCallSpec extends AnyFlatSpec {
       s"MetaCall failed to load the script with code $retCode"
     )
 
-    val ret = Bindings.instance.metacallhv_s(
+    val ret = metacall.metacallhv_s(
       handleRef.getValue(),
       "fn_in_s1",
       Array(),
@@ -440,7 +444,7 @@ class MetaCallSpec extends AnyFlatSpec {
           argValues match {
             case StringValue(s) :: Nil =>
               Ptr.fromValueUnsafe(StringValue("Hello, " + s)).ptr
-            case _ => Bindings.instance.metacall_value_create_null()
+            case _ => metacall.metacall_value_create_null()
           }
         }
       }
@@ -456,7 +460,7 @@ class MetaCallSpec extends AnyFlatSpec {
   "MetaCall" should "be destroyed successfully" in {
     // TODO: Remove this if we drop support for executing Scala outside of MetaCall
     // TODO: Create a destroy method wrapping this functionality
-    if (System.getProperty("java.polyglot.name") != "metacall") {
+    if (System.getProperty("metacall.polyglot.name") != "core") {
       assert(
         metacall.metacall_destroy() == 0,
         "MetaCall was not successfully destroyed"

source/tests/java_loader_test/CMakeLists.txt

@@ -126,8 +126,11 @@ target_link_libraries(${target}
 #
 
 add_test(NAME ${target}
-	WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+	# WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
 	COMMAND $<TARGET_FILE:${target}>
+
+	# TODO: Remove this
+	WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/source/ports/scala_port
 )
 
 #