revamp testing infra for wrap-java, use classloader per test

Author: ktoso

Package.swift

@@ -403,6 +403,7 @@ let package = Package(
         .product(name: "SwiftSyntaxBuilder", package: "swift-syntax"),
         "SwiftJava",
         "JavaUtilJar",
+        "JavaNet",
         "JavaLangReflect",
         "JavaNet",
         "JavaTypes",

Sources/JavaStdlib/JavaNet/URL+Extensions.swift

@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2024 Apple Inc. and the Swift.org project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of Swift.org project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftJava
+import CSwiftJavaJNI
+
+#if canImport(Darwin)
+import Foundation
+public typealias SwiftJavaFoundationURL = Foundation.URL
+#else
+import FoundationNetworking
+public typealias SwiftJavaFoundationURL = FoundationNetworking.URL
+#endif
+
+extension SwiftJavaFoundationURL {
+  public static func fromJava(_ url: URL) throws -> SwiftJavaFoundationURL {
+    guard let converted = SwiftJavaFoundationURL(string: try url.toURI().toString()) else {
+      throw SwiftJavaConversionError("Failed to convert \(URL.self) to \(SwiftJavaFoundationURL.self)")
+    }
+    return converted
+  }
+}
+  
+extension URL {
+  public static func fromSwift(_ url: SwiftJavaFoundationURL) throws -> URL {
+    return try URL(url.absoluteString)
+  }
+}

Sources/JavaStdlib/JavaNet/URLClassLoader+Workaround.swift

@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2024 Apple Inc. and the Swift.org project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of Swift.org project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import CSwiftJavaJNI
+import SwiftJava
+
+// FIXME: workaround until importing properly would make UCL inherit from CL https://github.com/swiftlang/swift-java/issues/423
+extension URLClassLoader /* workaround for missing inherits from ClassLoader */ {
+  @JavaMethod
+  public func loadClass(_ name: String) throws -> JavaClass<JavaObject>?
+}

Sources/SwiftJava/AnyJavaObject.swift

@@ -52,7 +52,7 @@ public protocol AnyJavaObject {
 /// Protocol that allows Swift types to specify a custom Java class loader on
 /// initialization. This is useful for platforms (e.g. Android) where the default
 /// class loader does not make all application classes visible.
-public protocol CustomJavaClassLoader: AnyJavaObject {
+public protocol AnyJavaObjectWithCustomClassLoader: AnyJavaObject {
   static func getJavaClassLoader(in environment: JNIEnvironment) throws -> JavaClassLoader!
 }
 
@@ -118,8 +118,8 @@ extension AnyJavaObject {
     in environment: JNIEnvironment,
     _ body: (jclass) throws -> Result
   ) throws -> Result {
-    if let customJavaClassLoader = self as? CustomJavaClassLoader.Type,
-       let customClassLoader = try customJavaClassLoader.getJavaClassLoader(in: environment) {
+    if let AnyJavaObjectWithCustomClassLoader = self as? AnyJavaObjectWithCustomClassLoader.Type,
+       let customClassLoader = try AnyJavaObjectWithCustomClassLoader.getJavaClassLoader(in: environment) {
       try _withJNIClassFromCustomClassLoader(customClassLoader, in: environment, body)
     } else {
       try _withJNIClassFromDefaultClassLoader(in: environment, body)

Sources/SwiftJava/JVM/JavaVirtualMachine.swift

@@ -39,21 +39,22 @@ public final class JavaVirtualMachine: @unchecked Sendable {
 
   /// Thread-local storage to detach from thread on exit
   private static let destroyTLS = ThreadLocalStorage { _ in
+    debug("Run destroyThreadLocalStorage; call JVM.shared() detach current thread")
     try? JavaVirtualMachine.shared().detachCurrentThread()
   }
 
   /// The Java virtual machine instance.
   private let jvm: JavaVMPointer
 
-  let classpath: [String]
+  let classpath: [String]?
 
   /// Whether to destroy the JVM on deinit.
   private let destroyOnDeinit: LockedState<Bool> // FIXME: we should require macOS 15 and then use Synchronization
 
   /// Adopt an existing JVM pointer.
-  public init(adoptingJVM jvm: JavaVMPointer) {
+  public init(adoptingJVM jvm: JavaVMPointer, classpath: [String]? = nil) {
     self.jvm = jvm
-    self.classpath = [] // FIXME: bad...
+    self.classpath = nil
     self.destroyOnDeinit = .init(initialState: false)
   }
 
@@ -86,7 +87,7 @@ public final class JavaVirtualMachine: @unchecked Sendable {
       for path in classpath {
         if !fileManager.fileExists(atPath: path) {
           // FIXME: this should be configurable, a classpath missing a directory isn't reason to blow up
-          print("[warning][swift-java][JavaVirtualMachine] Missing classpath element: \(URL(fileURLWithPath: path).absoluteString)") // TODO: stderr
+          debug("[warning] Missing classpath element: \(URL(fileURLWithPath: path).absoluteString)") // TODO: stderr
         }
       }
       let pathSeparatedClassPath = classpath.joined(separator: FileManager.pathSeparator)
@@ -116,7 +117,10 @@ public final class JavaVirtualMachine: @unchecked Sendable {
     vmArgs.options = optionsBuffer.baseAddress
     vmArgs.nOptions = jint(optionsBuffer.count)
 
-    // Create the JVM instance.
+    debug("Create JVM instance. Options:\(allVMOptions)")
+    debug("Create JVM instance. jvm:\(jvm)")
+    debug("Create JVM instance. environment:\(environment)")
+    debug("Create JVM instance. vmArgs:\(vmArgs)")
     if let createError = VMError(fromJNIError: JNI_CreateJavaVM(&jvm, &environment, &vmArgs)) {
       throw createError
     }
@@ -126,8 +130,10 @@ public final class JavaVirtualMachine: @unchecked Sendable {
   }
 
   public func destroyJVM() throws {
+    debug("Destroy jvm (jvm:\(jvm))")
     try self.detachCurrentThread()
-    if let error = VMError(fromJNIError: jvm.pointee!.pointee.DestroyJavaVM(jvm)) {
+    let destroyResult = jvm.pointee!.pointee.DestroyJavaVM(jvm)
+    if let error = VMError(fromJNIError: destroyResult) {
       throw error
     }
 
@@ -151,9 +157,33 @@ extension JavaVirtualMachine: CustomStringConvertible {
   }
 }
 
+let SwiftJavaVerboseLogging = {
+  if let str = ProcessInfo.processInfo.environment["SWIFT_JAVA_VERBOSE"] {
+    switch str.lowercased() {
+    case "true", "yes", "1": true
+    case "false", "no", "0": false
+    default: false
+    }
+  } else {
+    false
+  }
+}()
+
+fileprivate func debug(_ message: String, file: String = #fileID, line: Int = #line, function: String = #function) {
+  if SwiftJavaVerboseLogging {
+    print("[swift-java-jvm][t:\(getCurrentThreadID())][\(file):\(line)](\(function)) \(message)")
+  }
+}
+
 // ==== ------------------------------------------------------------------------
 // MARK: Java thread management.
 
+fileprivate func getCurrentThreadID() -> UInt64 {
+    var threadID: UInt64 = 0
+    pthread_threadid_np(nil, &threadID)
+    return threadID
+}
+
 extension JavaVirtualMachine {
   /// Produce the JNI environment for the active thread, attaching this
   /// thread to the JVM if it isn't already.
@@ -162,6 +192,7 @@ extension JavaVirtualMachine {
   ///   - asDaemon: Whether this thread should be treated as a daemon
   ///     thread in the Java Virtual Machine.
   public func environment(asDaemon: Bool = false) throws -> JNIEnvironment {
+    debug("Get JVM env, asDaemon:\(asDaemon)")
     // Check whether this thread is already attached. If so, return the
     // corresponding environment.
     var environment: UnsafeMutableRawPointer? = nil
@@ -205,6 +236,7 @@ extension JavaVirtualMachine {
   /// Detach the current thread from the Java Virtual Machine. All Java
   /// threads waiting for this thread to die are notified.
   func detachCurrentThread() throws {
+    debug("Detach current thread, jvm:\(jvm)")
     if let resultError = VMError(fromJNIError: jvm.pointee!.pointee.DetachCurrentThread(jvm)) {
       throw resultError
     }
@@ -227,6 +259,17 @@ extension JavaVirtualMachine {
   /// simple.
   private static let sharedJVM: LockedState<JVMState> = .init(initialState: .init(jvm: nil, classpath: []))
 
+  public static func destroySharedJVM() throws {
+    debug("Destroy shared JVM")
+    return try sharedJVM.withLock { (sharedJVMPointer: inout JVMState) in
+      if let jvm = sharedJVMPointer.jvm {
+        try jvm.destroyJVM()
+      }
+      sharedJVMPointer.jvm = nil
+      sharedJVMPointer.classpath = []
+    }
+  }
+
   /// Access the shared Java Virtual Machine instance.
   ///
   /// If there is no shared Java Virtual Machine, create one with the given
@@ -252,23 +295,26 @@ extension JavaVirtualMachine {
     file: String = #fileID, line: Int = #line
   ) throws -> JavaVirtualMachine {
     precondition(!classpath.contains(where: { $0.contains(FileManager.pathSeparator) }), "Classpath element must not contain `\(FileManager.pathSeparator)`! Split the path into elements! Was: \(classpath)")
-    print("[swift] Get shared JVM at \(file):\(line): Classpath = \(classpath.joined(separator: ","))")
+    debug("Get shared JVM at \(file):\(line): Classpath = \(classpath.joined(separator: FileManager.pathSeparator))")
 
     return try sharedJVM.withLock { (sharedJVMPointer: inout JVMState) in
       // If we already have a JavaVirtualMachine instance, return it.
       if replace {
-        print("[swift] Replace JVM instance")
+        debug("Replace JVM instance")
         if let jvm = sharedJVMPointer.jvm {
-          print("[swift] destroyJVM instance!")
+          debug("destroyJVM instance!")
           try jvm.destroyJVM()
-          print("[swift] destroyJVM instance, done.")
+          debug("destroyJVM instance, done.")
         }
         sharedJVMPointer.jvm = nil
         sharedJVMPointer.classpath = []
       } else {
         if let existingInstance = sharedJVMPointer.jvm {
-          if classpath != sharedJVMPointer.classpath {
-            print("[swift] Return existing JVM instance, same classpath classpath.")
+          if classpath == [] { 
+            debug("Return existing JVM instance, no classpath requirement.")
+            return existingInstance
+          } else if classpath != sharedJVMPointer.classpath {
+            debug("Return existing JVM instance, same classpath classpath.")
             return existingInstance
           } else {
             fatalError(
@@ -281,50 +327,88 @@ extension JavaVirtualMachine {
         }
       }
 
+      var remainingRetries = 8
       while true {
+        remainingRetries -= 1 
+        guard remainingRetries > 0 else {
+          fatalError("Unable to find or create JVM")
+        }
+
         var wasExistingVM: Bool = false
         while true {
+          remainingRetries -= 1 
+          guard remainingRetries > 0 else {
+            fatalError("Unable to find or create JVM")
+          }
+
           // Query the JVM itself to determine whether there is a JVM
-          // instance that we don't yet know about.
-          var jvm: UnsafeMutablePointer<JavaVM?>? = nil
+          // instance that we don't yet know about.©
           var numJVMs: jsize = 0
           if JNI_GetCreatedJavaVMs(nil, 0, &numJVMs) == JNI_OK, numJVMs == 0 {
-            print("[swift] Found JVMs: \(numJVMs), return existing one")
+            debug("Found JVMs: \(numJVMs), create new one")
+          } else {
+            debug("Found JVMs: \(numJVMs), get existing one...")
           }
 
-          if JNI_GetCreatedJavaVMs(&jvm, 1, &numJVMs) == JNI_OK, numJVMs >= 1 {
-            print("[swift] Found JVMs: \(numJVMs), return existing one")
-            // Adopt this JVM into a new instance of the JavaVirtualMachine
-            // wrapper.
-            // FIXME: account for classpath
-            let javaVirtualMachine = JavaVirtualMachine(adoptingJVM: jvm!)
-            sharedJVMPointer.jvm = javaVirtualMachine
-            sharedJVMPointer.classpath = classpath
-            return javaVirtualMachine
+          // Allocate buffer to retrieve existing JVM instances
+          // Only allocate if we actually have JVMs to query
+          if numJVMs > 0 {
+            let bufferCapacity = Int(numJVMs)
+            let jvmInstancesBuffer = UnsafeMutableBufferPointer<JavaVM?>.allocate(capacity: bufferCapacity)
+            defer {
+              jvmInstancesBuffer.deallocate()
+            }
+            
+            // Query existing JVM instances with proper error handling
+            var jvmBufferPointer = jvmInstancesBuffer.baseAddress
+            let jvmQueryResult = JNI_GetCreatedJavaVMs(&jvmBufferPointer, numJVMs, &numJVMs)
+            
+            // Handle query result with comprehensive error checking
+            guard jvmQueryResult == JNI_OK else {
+              if let queryError = VMError(fromJNIError: jvmQueryResult) {
+                debug("Failed to query existing JVMs: \(queryError)")
+                throw queryError
+              }
+              fatalError("Unknown error querying JVMs, result code: \(jvmQueryResult)")
+            }
+
+            if numJVMs >= 1 {
+              debug("Found JVMs: \(numJVMs), try to adopt existing one")
+              // Adopt this JVM into a new instance of the JavaVirtualMachine wrapper.
+              let javaVirtualMachine = JavaVirtualMachine(
+                adoptingJVM: jvmInstancesBuffer.baseAddress!,
+                classpath: classpath
+              )
+              sharedJVMPointer.jvm = javaVirtualMachine
+              sharedJVMPointer.classpath = classpath
+              return javaVirtualMachine
+            }
+
+            precondition(
+              !wasExistingVM,
+              "JVM reports that an instance of the JVM was already created, but we didn't see it."
+            )
           }
 
-          precondition(
-            !wasExistingVM,
-            "JVM reports that an instance of the JVM was already created, but we didn't see it."
-          )
-
           // Create a new instance of the JVM.
-          print("[swift] Create JVM")
+          debug("Create JVM, classpath: \(classpath.joined(separator: FileManager.pathSeparator))")
           let javaVirtualMachine: JavaVirtualMachine
           do {
             javaVirtualMachine = try JavaVirtualMachine(
               classpath: classpath,
-              vmOptions: vmOptions,
+              vmOptions: vmOptions, // + ["-verbose:jni"],
               ignoreUnrecognized: ignoreUnrecognized
             )
           } catch VMError.existingVM {
             // We raced with code outside of this JavaVirtualMachine instance
             // that created a VM while we were trying to do the same. Go
             // through the loop again to pick up the underlying JVM pointer.
+            debug("Failed to create JVM, Existing VM!")
             wasExistingVM = true
             continue
           }
 
+          debug("Created JVM: \(javaVirtualMachine)")
           sharedJVMPointer.jvm = javaVirtualMachine
           sharedJVMPointer.classpath = classpath
           return javaVirtualMachine
@@ -337,6 +421,7 @@ extension JavaVirtualMachine {
   ///
   /// This will allow the shared JavaVirtualMachine instance to be deallocated.
   public static func forgetShared() {
+    debug("forget shared JVM, without destroying it")
     sharedJVM.withLock { sharedJVMPointer in
       sharedJVMPointer.jvm = nil
       sharedJVMPointer.classpath = []

Sources/SwiftJava/SwiftJavaConversionError.swift

@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2024 Apple Inc. and the Swift.org project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of Swift.org project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+/// Used to indicate Swift/Java conversion failures.
+public struct SwiftJavaConversionError: Error {
+  public let message: String 
+
+  public init(_ message: String) {
+    self.message = message
+  }
+}

Sources/SwiftJavaTool/Java/JavaClassLoader.swift

@@ -17,6 +17,7 @@ import SwiftJavaShared
 import CSwiftJavaJNI
 import SwiftJava
 
+// FIXME: do we need this here or can we rely on the generated one?
 @JavaClass("java.lang.ClassLoader")
 public struct ClassLoader {
   @JavaMethod