rustjava-runtime 0.4.1

A Java standard library implementation for RustJava
Documentation
use jvm::{Array, ClassInstanceRef, JavaError, Result, runtime::JavaLangString};
use rustjava_runtime::classes::java::{
    io::{ByteArrayOutputStream, OutputStream},
    lang::String,
    util::logging::{Formatter, Handler, Level, LogManager, Logger},
};
use test_utils::test_jvm;

#[tokio::test]
async fn named_loggers_are_reused_and_reparented_when_ancestor_is_added_late() -> Result<()> {
    let jvm = test_jvm().await?;
    let child_name = JavaLangString::from_rust_string(&jvm, "app.service.worker").await?;
    let child: ClassInstanceRef<Logger> = jvm
        .invoke_static(
            "java/util/logging/Logger",
            "getLogger",
            "(Ljava/lang/String;)Ljava/util/logging/Logger;",
            (child_name.clone(),),
        )
        .await?;
    let same: ClassInstanceRef<Logger> = jvm
        .invoke_static(
            "java/util/logging/Logger",
            "getLogger",
            "(Ljava/lang/String;)Ljava/util/logging/Logger;",
            (child_name,),
        )
        .await?;
    assert_eq!(child.identity(), same.identity());

    let parent_name = JavaLangString::from_rust_string(&jvm, "app.service").await?;
    let parent: ClassInstanceRef<Logger> = jvm
        .invoke_static(
            "java/util/logging/Logger",
            "getLogger",
            "(Ljava/lang/String;)Ljava/util/logging/Logger;",
            (parent_name,),
        )
        .await?;
    let actual: ClassInstanceRef<Logger> = jvm
        .invoke_virtual(&child, "java/util/logging/Logger", "getParent", "()Ljava/util/logging/Logger;", ())
        .await?;
    assert_eq!(actual.identity(), parent.identity());
    Ok(())
}

#[tokio::test]
async fn existing_logger_preserves_and_validates_resource_bundle_name() -> Result<()> {
    let jvm = test_jvm().await?;
    let name = JavaLangString::from_rust_string(&jvm, "bundled.logger").await?;
    let logger: ClassInstanceRef<Logger> = jvm
        .invoke_static(
            "java/util/logging/Logger",
            "getLogger",
            "(Ljava/lang/String;)Ljava/util/logging/Logger;",
            (name.clone(),),
        )
        .await?;
    let bundle = JavaLangString::from_rust_string(&jvm, "messages").await?;
    let bundled: ClassInstanceRef<Logger> = jvm
        .invoke_static(
            "java/util/logging/Logger",
            "getLogger",
            "(Ljava/lang/String;Ljava/lang/String;)Ljava/util/logging/Logger;",
            (name.clone(), bundle.clone()),
        )
        .await?;
    assert_eq!(logger.identity(), bundled.identity());
    let actual: ClassInstanceRef<String> = jvm
        .invoke_virtual(&logger, "java/util/logging/Logger", "getResourceBundleName", "()Ljava/lang/String;", ())
        .await?;
    assert_eq!(JavaLangString::to_rust_string(&jvm, &actual).await?, "messages");

    let same: ClassInstanceRef<Logger> = jvm
        .invoke_static(
            "java/util/logging/Logger",
            "getLogger",
            "(Ljava/lang/String;Ljava/lang/String;)Ljava/util/logging/Logger;",
            (name.clone(), bundle),
        )
        .await?;
    assert_eq!(logger.identity(), same.identity());

    let result: Result<ClassInstanceRef<Logger>> = jvm
        .invoke_static(
            "java/util/logging/Logger",
            "getLogger",
            "(Ljava/lang/String;Ljava/lang/String;)Ljava/util/logging/Logger;",
            (name, JavaLangString::from_rust_string(&jvm, "other").await?),
        )
        .await;
    let Err(JavaError::JavaException(exception)) = result else {
        panic!("a different resource bundle name must throw IllegalArgumentException");
    };
    assert!(jvm.is_instance(&*exception, "java/lang/IllegalArgumentException"));
    Ok(())
}

#[tokio::test]
async fn logger_inherits_levels_and_publishes_convenience_methods() -> Result<()> {
    let jvm = test_jvm().await?;
    let logger: ClassInstanceRef<Logger> = jvm
        .invoke_static(
            "java/util/logging/Logger",
            "getLogger",
            "(Ljava/lang/String;)Ljava/util/logging/Logger;",
            (JavaLangString::from_rust_string(&jvm, "output.test").await?,),
        )
        .await?;
    let _: () = jvm
        .invoke_virtual(&logger, "java/util/logging/Logger", "setUseParentHandlers", "(Z)V", (false,))
        .await?;

    let output: ClassInstanceRef<ByteArrayOutputStream> = jvm.new_class("java/io/ByteArrayOutputStream", "()V", ()).await?.into();
    let formatter: ClassInstanceRef<Formatter> = jvm.new_class("java/util/logging/SimpleFormatter", "()V", ()).await?.into();
    let handler: ClassInstanceRef<Handler> = jvm
        .new_class(
            "java/util/logging/StreamHandler",
            "(Ljava/io/OutputStream;Ljava/util/logging/Formatter;)V",
            (ClassInstanceRef::<OutputStream>::new(output.instance.clone()), formatter),
        )
        .await?
        .into();
    let _: () = jvm
        .invoke_virtual(
            &logger,
            "java/util/logging/Logger",
            "addHandler",
            "(Ljava/util/logging/Handler;)V",
            (handler.clone(),),
        )
        .await?;

    let warning: ClassInstanceRef<Level> = jvm
        .get_static_field("java/util/logging/Level", "WARNING", "Ljava/util/logging/Level;")
        .await?;
    let _: () = jvm
        .invoke_virtual(
            &logger,
            "java/util/logging/Logger",
            "setLevel",
            "(Ljava/util/logging/Level;)V",
            (warning,),
        )
        .await?;
    let _: () = jvm
        .invoke_virtual(
            &logger,
            "java/util/logging/Logger",
            "info",
            "(Ljava/lang/String;)V",
            (JavaLangString::from_rust_string(&jvm, "hidden").await?,),
        )
        .await?;
    let _: () = jvm
        .invoke_virtual(
            &logger,
            "java/util/logging/Logger",
            "warning",
            "(Ljava/lang/String;)V",
            (JavaLangString::from_rust_string(&jvm, "visible").await?,),
        )
        .await?;
    let _: () = jvm.invoke_virtual(&handler, "java/util/logging/Handler", "flush", "()V", ()).await?;

    let text: ClassInstanceRef<String> = jvm
        .invoke_virtual(&output, "java/io/ByteArrayOutputStream", "toString", "()Ljava/lang/String;", ())
        .await?;
    let text = JavaLangString::to_rust_string(&jvm, &text).await?;
    assert!(!text.contains("hidden"));
    assert!(text.contains("visible"));
    Ok(())
}

#[tokio::test]
async fn logger_publishes_to_parent_handlers_until_propagation_is_disabled() -> Result<()> {
    let jvm = test_jvm().await?;
    let parent: ClassInstanceRef<Logger> = jvm
        .invoke_static(
            "java/util/logging/Logger",
            "getLogger",
            "(Ljava/lang/String;)Ljava/util/logging/Logger;",
            (JavaLangString::from_rust_string(&jvm, "propagation").await?,),
        )
        .await?;
    let child: ClassInstanceRef<Logger> = jvm
        .invoke_static(
            "java/util/logging/Logger",
            "getLogger",
            "(Ljava/lang/String;)Ljava/util/logging/Logger;",
            (JavaLangString::from_rust_string(&jvm, "propagation.child").await?,),
        )
        .await?;
    let _: () = jvm
        .invoke_virtual(&parent, "java/util/logging/Logger", "setUseParentHandlers", "(Z)V", (false,))
        .await?;

    let output: ClassInstanceRef<ByteArrayOutputStream> = jvm.new_class("java/io/ByteArrayOutputStream", "()V", ()).await?.into();
    let formatter: ClassInstanceRef<Formatter> = jvm.new_class("java/util/logging/SimpleFormatter", "()V", ()).await?.into();
    let handler: ClassInstanceRef<Handler> = jvm
        .new_class(
            "java/util/logging/StreamHandler",
            "(Ljava/io/OutputStream;Ljava/util/logging/Formatter;)V",
            (ClassInstanceRef::<OutputStream>::new(output.instance.clone()), formatter),
        )
        .await?
        .into();
    let _: () = jvm
        .invoke_virtual(
            &parent,
            "java/util/logging/Logger",
            "addHandler",
            "(Ljava/util/logging/Handler;)V",
            (handler.clone(),),
        )
        .await?;

    let _: () = jvm
        .invoke_virtual(
            &child,
            "java/util/logging/Logger",
            "info",
            "(Ljava/lang/String;)V",
            (JavaLangString::from_rust_string(&jvm, "from child").await?,),
        )
        .await?;
    let _: () = jvm.invoke_virtual(&handler, "java/util/logging/Handler", "flush", "()V", ()).await?;
    let text: ClassInstanceRef<String> = jvm
        .invoke_virtual(&output, "java/io/ByteArrayOutputStream", "toString", "()Ljava/lang/String;", ())
        .await?;
    assert!(JavaLangString::to_rust_string(&jvm, &text).await?.contains("from child"));

    let _: () = jvm
        .invoke_virtual(&child, "java/util/logging/Logger", "setUseParentHandlers", "(Z)V", (false,))
        .await?;
    let _: () = jvm
        .invoke_virtual(
            &child,
            "java/util/logging/Logger",
            "info",
            "(Ljava/lang/String;)V",
            (JavaLangString::from_rust_string(&jvm, "not propagated").await?,),
        )
        .await?;
    let _: () = jvm.invoke_virtual(&handler, "java/util/logging/Handler", "flush", "()V", ()).await?;
    let text: ClassInstanceRef<String> = jvm
        .invoke_virtual(&output, "java/io/ByteArrayOutputStream", "toString", "()Ljava/lang/String;", ())
        .await?;
    assert!(!JavaLangString::to_rust_string(&jvm, &text).await?.contains("not propagated"));
    Ok(())
}

#[tokio::test]
async fn log_manager_reset_removes_handlers_and_restores_levels() -> Result<()> {
    let jvm = test_jvm().await?;
    let manager: ClassInstanceRef<LogManager> = jvm
        .invoke_static("java/util/logging/LogManager", "getLogManager", "()Ljava/util/logging/LogManager;", ())
        .await?;
    let logger: ClassInstanceRef<Logger> = jvm
        .invoke_static(
            "java/util/logging/Logger",
            "getLogger",
            "(Ljava/lang/String;)Ljava/util/logging/Logger;",
            (JavaLangString::from_rust_string(&jvm, "reset.test").await?,),
        )
        .await?;
    let output: ClassInstanceRef<ByteArrayOutputStream> = jvm.new_class("java/io/ByteArrayOutputStream", "()V", ()).await?.into();
    let formatter: ClassInstanceRef<Formatter> = jvm.new_class("java/util/logging/SimpleFormatter", "()V", ()).await?.into();
    let handler: ClassInstanceRef<Handler> = jvm
        .new_class(
            "java/util/logging/StreamHandler",
            "(Ljava/io/OutputStream;Ljava/util/logging/Formatter;)V",
            (ClassInstanceRef::<OutputStream>::new(output.instance), formatter),
        )
        .await?
        .into();
    let severe: ClassInstanceRef<Level> = jvm
        .get_static_field("java/util/logging/Level", "SEVERE", "Ljava/util/logging/Level;")
        .await?;
    let _: () = jvm
        .invoke_virtual(
            &logger,
            "java/util/logging/Logger",
            "addHandler",
            "(Ljava/util/logging/Handler;)V",
            (handler,),
        )
        .await?;
    let _: () = jvm
        .invoke_virtual(&logger, "java/util/logging/Logger", "setLevel", "(Ljava/util/logging/Level;)V", (severe,))
        .await?;

    let _: () = jvm.invoke_virtual(&manager, "java/util/logging/LogManager", "reset", "()V", ()).await?;

    let handlers: ClassInstanceRef<Array<Handler>> = jvm
        .invoke_virtual(&logger, "java/util/logging/Logger", "getHandlers", "()[Ljava/util/logging/Handler;", ())
        .await?;
    assert_eq!(jvm.array_length(&handlers).await?, 0);
    let level: ClassInstanceRef<Level> = jvm
        .invoke_virtual(&logger, "java/util/logging/Logger", "getLevel", "()Ljava/util/logging/Level;", ())
        .await?;
    assert!(level.is_null());

    let root: ClassInstanceRef<Logger> = jvm
        .invoke_virtual(
            &manager,
            "java/util/logging/LogManager",
            "getLogger",
            "(Ljava/lang/String;)Ljava/util/logging/Logger;",
            (JavaLangString::from_rust_string(&jvm, "").await?,),
        )
        .await?;
    let root_level: ClassInstanceRef<Level> = jvm
        .invoke_virtual(&root, "java/util/logging/Logger", "getLevel", "()Ljava/util/logging/Level;", ())
        .await?;
    let value: i32 = jvm.invoke_virtual(&root_level, "java/util/logging/Level", "intValue", "()I", ()).await?;
    assert_eq!(value, 800);
    Ok(())
}

#[tokio::test]
async fn global_logger_and_manager_initialize_in_either_entry_order() -> Result<()> {
    let jvm = test_jvm().await?;
    let global: ClassInstanceRef<Logger> = jvm
        .get_static_field("java/util/logging/Logger", "global", "Ljava/util/logging/Logger;")
        .await?;
    let manager: ClassInstanceRef<LogManager> = jvm
        .invoke_static("java/util/logging/LogManager", "getLogManager", "()Ljava/util/logging/LogManager;", ())
        .await?;
    let name = JavaLangString::from_rust_string(&jvm, "global").await?;
    let registered: ClassInstanceRef<Logger> = jvm
        .invoke_virtual(
            &manager,
            "java/util/logging/LogManager",
            "getLogger",
            "(Ljava/lang/String;)Ljava/util/logging/Logger;",
            (name,),
        )
        .await?;
    assert_eq!(global.identity(), registered.identity());

    let jvm = test_jvm().await?;
    let manager: ClassInstanceRef<LogManager> = jvm
        .invoke_static("java/util/logging/LogManager", "getLogManager", "()Ljava/util/logging/LogManager;", ())
        .await?;
    let global: ClassInstanceRef<Logger> = jvm
        .get_static_field("java/util/logging/Logger", "global", "Ljava/util/logging/Logger;")
        .await?;
    let name = JavaLangString::from_rust_string(&jvm, "global").await?;
    let registered: ClassInstanceRef<Logger> = jvm
        .invoke_virtual(
            &manager,
            "java/util/logging/LogManager",
            "getLogger",
            "(Ljava/lang/String;)Ljava/util/logging/Logger;",
            (name,),
        )
        .await?;
    assert_eq!(global.identity(), registered.identity());
    Ok(())
}