rustjava-runtime 0.3.5

A Java standard library implementation for RustJava
Documentation
use alloc::{string::String as RustString, vec::Vec};

use jvm::{Array, ClassInstanceRef, JavaError, Jvm, Result, runtime::JavaLangString};
use jvm_types::MethodAccessFlags;
use rustjava_runtime::{
    classes::java::{
        lang::{CharSequence, String},
        util::regex::Pattern,
    },
    get_runtime_class_proto,
};

use test_utils::test_jvm;

async fn split(jvm: &Jvm, input: &str, source: &str, limit: i32) -> Result<Vec<RustString>> {
    let source = JavaLangString::from_rust_string(jvm, source).await?;
    let pattern: ClassInstanceRef<Pattern> = jvm
        .invoke_static(
            "java/util/regex/Pattern",
            "compile",
            "(Ljava/lang/String;)Ljava/util/regex/Pattern;",
            (source,),
        )
        .await?;
    let input: ClassInstanceRef<CharSequence> = JavaLangString::from_rust_string(jvm, input).await?.into();
    let values: ClassInstanceRef<Array<String>> = jvm
        .invoke_virtual(
            &pattern,
            "java/util/regex/Pattern",
            "split",
            "(Ljava/lang/CharSequence;I)[Ljava/lang/String;",
            (input, limit),
        )
        .await?;
    let mut result = Vec::new();
    for value in jvm
        .load_array::<ClassInstanceRef<String>>(&values, 0, jvm.array_length(&values).await?)
        .await?
    {
        result.push(JavaLangString::to_rust_string(jvm, &value).await?);
    }
    Ok(result)
}

#[tokio::test]
async fn pattern_exposes_java_14_split_methods() -> Result<()> {
    let proto = get_runtime_class_proto("java/util/regex/Pattern").expect("Pattern must be registered");
    for descriptor in [
        "(Ljava/lang/CharSequence;)[Ljava/lang/String;",
        "(Ljava/lang/CharSequence;I)[Ljava/lang/String;",
    ] {
        let method = proto
            .methods
            .iter()
            .find(|method| method.name == "split" && method.descriptor == descriptor)
            .unwrap_or_else(|| panic!("missing Pattern.split{descriptor}"));
        assert_eq!(method.access_flags, MethodAccessFlags::PUBLIC);
    }

    Ok(())
}

#[tokio::test]
async fn split_applies_positive_negative_and_zero_limits() -> Result<()> {
    let jvm = test_jvm().await?;
    for (input, source, limit, expected) in [
        ("boo:and:foo", ":", 2, vec!["boo", "and:foo"]),
        ("boo:and:foo", ":", 5, vec!["boo", "and", "foo"]),
        ("boo:and:foo", ":", -2, vec!["boo", "and", "foo"]),
        ("boo:and:foo", "o", 5, vec!["b", "", ":and:f", "", ""]),
        ("boo:and:foo", "o", -2, vec!["b", "", ":and:f", "", ""]),
        ("boo:and:foo", "o", 0, vec!["b", "", ":and:f"]),
        ("a:", ":", i32::MIN, vec!["a", ""]),
        ("a:", ":", i32::MAX, vec!["a", ""]),
    ] {
        assert_eq!(split(&jvm, input, source, limit).await?, expected);
    }

    Ok(())
}

#[tokio::test]
async fn split_handles_no_match_whole_input_and_empty_input() -> Result<()> {
    let jvm = test_jvm().await?;
    for limit in [0, 2, -1] {
        assert_eq!(split(&jvm, "abc", ":", limit).await?, vec!["abc"]);
    }
    for (limit, expected) in [(0, Vec::<&str>::new()), (-1, vec!["", ""]), (1, vec!["abc"])] {
        assert_eq!(split(&jvm, "abc", "abc", limit).await?, expected);
    }
    for limit in [0, 1, -1] {
        assert_eq!(split(&jvm, "", ":", limit).await?, vec![""]);
        assert_eq!(split(&jvm, "", "", limit).await?, vec![""]);
    }

    Ok(())
}

#[tokio::test]
async fn split_preserves_java_14_zero_width_leading_behavior() -> Result<()> {
    let jvm = test_jvm().await?;
    assert_eq!(split(&jvm, "abc", "^", 0).await?, vec!["abc"]);
    assert_eq!(split(&jvm, "ab", "", 0).await?, vec!["", "a", "b"]);
    assert_eq!(split(&jvm, "ab", "", -1).await?, vec!["", "a", "b", ""]);
    assert_eq!(split(&jvm, "ab", "", 1).await?, vec!["ab"]);
    assert_eq!(split(&jvm, "ab", "^|b", -1).await?, vec!["", "a", ""]);

    Ok(())
}

#[tokio::test]
async fn split_uses_utf16_boundaries_and_keeps_leading_empty_parts() -> Result<()> {
    let jvm = test_jvm().await?;
    assert_eq!(split(&jvm, ":a", ":", -1).await?, vec!["", "a"]);
    assert_eq!(split(&jvm, "A😀B😀", "😀", -1).await?, vec!["A", "B", ""]);

    Ok(())
}

#[tokio::test]
async fn split_without_limit_matches_an_explicit_zero_limit() -> Result<()> {
    let jvm = test_jvm().await?;
    let source = JavaLangString::from_rust_string(&jvm, "o").await?;
    let pattern: ClassInstanceRef<Pattern> = jvm
        .invoke_static(
            "java/util/regex/Pattern",
            "compile",
            "(Ljava/lang/String;)Ljava/util/regex/Pattern;",
            (source,),
        )
        .await?;
    let input: ClassInstanceRef<CharSequence> = JavaLangString::from_rust_string(&jvm, "boo:and:foo").await?.into();
    let implicit: ClassInstanceRef<Array<String>> = jvm
        .invoke_virtual(
            &pattern,
            "java/util/regex/Pattern",
            "split",
            "(Ljava/lang/CharSequence;)[Ljava/lang/String;",
            (input.clone(),),
        )
        .await?;
    let explicit: ClassInstanceRef<Array<String>> = jvm
        .invoke_virtual(
            &pattern,
            "java/util/regex/Pattern",
            "split",
            "(Ljava/lang/CharSequence;I)[Ljava/lang/String;",
            (input, 0),
        )
        .await?;

    let implicit = jvm
        .load_array::<ClassInstanceRef<String>>(&implicit, 0, jvm.array_length(&implicit).await?)
        .await?;
    let explicit = jvm
        .load_array::<ClassInstanceRef<String>>(&explicit, 0, jvm.array_length(&explicit).await?)
        .await?;
    assert_eq!(implicit.len(), explicit.len());
    for (implicit, explicit) in implicit.into_iter().zip(explicit) {
        assert_eq!(
            JavaLangString::to_rust_string(&jvm, &implicit).await?,
            JavaLangString::to_rust_string(&jvm, &explicit).await?
        );
    }

    Ok(())
}

#[tokio::test]
async fn split_accepts_string_buffer_and_returns_a_java_string_array() -> Result<()> {
    let jvm = test_jvm().await?;
    let source = JavaLangString::from_rust_string(&jvm, ":").await?;
    let pattern: ClassInstanceRef<Pattern> = jvm
        .invoke_static(
            "java/util/regex/Pattern",
            "compile",
            "(Ljava/lang/String;)Ljava/util/regex/Pattern;",
            (source,),
        )
        .await?;
    let value = JavaLangString::from_rust_string(&jvm, "a:b").await?;
    let buffer = jvm.new_class("java/lang/StringBuffer", "(Ljava/lang/String;)V", (value,)).await?;
    let input: ClassInstanceRef<CharSequence> = ClassInstanceRef::new(Some(buffer));
    let values: ClassInstanceRef<Array<String>> = jvm
        .invoke_virtual(
            &pattern,
            "java/util/regex/Pattern",
            "split",
            "(Ljava/lang/CharSequence;I)[Ljava/lang/String;",
            (input, -1),
        )
        .await?;
    assert_eq!(values.class_definition().name(), "[Ljava/lang/String;");

    let values = jvm
        .load_array::<ClassInstanceRef<String>>(&values, 0, jvm.array_length(&values).await?)
        .await?;
    let mut result = Vec::new();
    for value in values {
        result.push(JavaLangString::to_rust_string(&jvm, &value).await?);
    }
    assert_eq!(result, vec!["a", "b"]);

    Ok(())
}

#[tokio::test]
async fn split_rejects_a_null_input() -> Result<()> {
    let jvm = test_jvm().await?;
    let source = JavaLangString::from_rust_string(&jvm, ":").await?;
    let pattern: ClassInstanceRef<Pattern> = jvm
        .invoke_static(
            "java/util/regex/Pattern",
            "compile",
            "(Ljava/lang/String;)Ljava/util/regex/Pattern;",
            (source,),
        )
        .await?;
    let input: ClassInstanceRef<CharSequence> = None.into();
    let result: Result<ClassInstanceRef<Array<String>>> = jvm
        .invoke_virtual(
            &pattern,
            "java/util/regex/Pattern",
            "split",
            "(Ljava/lang/CharSequence;I)[Ljava/lang/String;",
            (input, 0),
        )
        .await;
    let Err(JavaError::JavaException(exception)) = result else {
        panic!("Pattern.split(null) must throw");
    };
    assert!(jvm.is_instance(&*exception, "java/lang/NullPointerException"));

    Ok(())
}