rustjava-runtime 0.3.3

A Java standard library implementation for RustJava
Documentation
use alloc::vec::Vec;

use jvm::{Array, ClassInstanceRef, JavaChar, JavaError, Result, runtime::JavaLangString};
use jvm_types::{ClassAccessFlags, MethodAccessFlags};
use rustjava_runtime::classes::java::{
    lang::{Object, String},
    util::StringTokenizer,
};

use test_utils::test_jvm;

#[tokio::test]
async fn tok_01_constructors_and_utf16_delimiters() -> Result<()> {
    let proto = StringTokenizer::as_proto();
    assert_eq!(proto.parent_class, Some("java/lang/Object"));
    assert_eq!(proto.interfaces, alloc::vec!["java/util/Enumeration"]);
    assert!(proto.access_flags.contains(ClassAccessFlags::PUBLIC));
    for descriptor in [
        "(Ljava/lang/String;)V",
        "(Ljava/lang/String;Ljava/lang/String;)V",
        "(Ljava/lang/String;Ljava/lang/String;Z)V",
    ] {
        let constructor = proto
            .methods
            .iter()
            .find(|method| method.name == "<init>" && method.descriptor == descriptor)
            .expect("StringTokenizer constructor");
        assert!(constructor.access_flags.contains(MethodAccessFlags::PUBLIC));
    }
    for (name, descriptor) in [
        ("hasMoreTokens", "()Z"),
        ("nextToken", "()Ljava/lang/String;"),
        ("nextToken", "(Ljava/lang/String;)Ljava/lang/String;"),
        ("countTokens", "()I"),
        ("hasMoreElements", "()Z"),
        ("nextElement", "()Ljava/lang/Object;"),
    ] {
        let method = proto
            .methods
            .iter()
            .find(|method| method.name == name && method.descriptor == descriptor)
            .expect("StringTokenizer token method");
        assert!(method.access_flags.contains(MethodAccessFlags::PUBLIC));
    }
    let fields = proto
        .fields
        .iter()
        .map(|field| (field.name.as_str(), field.descriptor.as_str()))
        .collect::<Vec<_>>();
    assert_eq!(
        fields,
        [
            ("str", "Ljava/lang/String;"),
            ("delimiters", "Ljava/lang/String;"),
            ("currentPosition", "I"),
            ("maxPosition", "I"),
            ("returnDelimiters", "Z"),
        ]
    );

    let jvm = test_jvm().await?;
    let input = JavaLangString::from_rust_string(&jvm, " one\t two\nthree ").await?;
    let tokenizer = jvm.new_class("java/util/StringTokenizer", "(Ljava/lang/String;)V", (input,)).await?;
    assert_eq!(
        jvm.get_field::<i32>(&tokenizer, "java/util/StringTokenizer", "maxPosition", "I").await?,
        16
    );
    assert_eq!(
        jvm.invoke_virtual::<_, i32>(&tokenizer, &tokenizer.class_definition().name(), "countTokens", "()I", ())
            .await?,
        3
    );
    for expected in ["one", "two", "three"] {
        let token: ClassInstanceRef<String> = jvm
            .invoke_virtual(&tokenizer, &tokenizer.class_definition().name(), "nextToken", "()Ljava/lang/String;", ())
            .await?;
        assert_eq!(JavaLangString::to_rust_string(&jvm, &token).await?, expected);
    }

    let mut input_chars = jvm.instantiate_array("C", 5).await?;
    jvm.store_array(
        &mut input_chars,
        0,
        [b'a' as JavaChar, 0xD800, b'b' as JavaChar, 0xD800, b'c' as JavaChar],
    )
    .await?;
    let utf16_input = jvm.new_class("java/lang/String", "([C)V", (input_chars,)).await?;
    let mut delimiter_chars = jvm.instantiate_array("C", 1).await?;
    jvm.store_array(&mut delimiter_chars, 0, [0xD800 as JavaChar]).await?;
    let utf16_delimiter = jvm.new_class("java/lang/String", "([C)V", (delimiter_chars,)).await?;
    let tokenizer = jvm
        .new_class(
            "java/util/StringTokenizer",
            "(Ljava/lang/String;Ljava/lang/String;Z)V",
            (utf16_input, utf16_delimiter, true),
        )
        .await?;

    assert_eq!(
        jvm.invoke_virtual::<_, i32>(&tokenizer, &tokenizer.class_definition().name(), "countTokens", "()I", ())
            .await?,
        5
    );
    let first: ClassInstanceRef<String> = jvm
        .invoke_virtual(&tokenizer, &tokenizer.class_definition().name(), "nextToken", "()Ljava/lang/String;", ())
        .await?;
    assert_eq!(JavaLangString::to_rust_string(&jvm, &first).await?, "a");
    let delimiter: ClassInstanceRef<String> = jvm
        .invoke_virtual(&tokenizer, &tokenizer.class_definition().name(), "nextToken", "()Ljava/lang/String;", ())
        .await?;
    assert_eq!(
        jvm.invoke_virtual::<_, i32>(&delimiter, "java/lang/String", "length", "()I", ()).await?,
        1
    );
    assert_eq!(
        jvm.invoke_virtual::<_, JavaChar>(&delimiter, "java/lang/String", "charAt", "(I)C", (0,))
            .await?,
        0xD800
    );

    let null_input: ClassInstanceRef<String> = None.into();
    let result = jvm.new_class("java/util/StringTokenizer", "(Ljava/lang/String;)V", (null_input,)).await;
    let Err(JavaError::JavaException(exception)) = result else {
        panic!("null input must throw NullPointerException");
    };
    assert!(jvm.is_instance(&*exception, "java/lang/NullPointerException"));

    Ok(())
}

#[tokio::test]
async fn tok_02_token_api_enumeration_and_delimiter_change() -> Result<()> {
    let jvm = test_jvm().await?;
    let input = JavaLangString::from_rust_string(&jvm, "a,b;c").await?;
    let comma = JavaLangString::from_rust_string(&jvm, ",").await?;
    let tokenizer = jvm
        .new_class("java/util/StringTokenizer", "(Ljava/lang/String;Ljava/lang/String;)V", (input, comma))
        .await?;

    assert!(
        jvm.invoke_virtual::<_, bool>(&tokenizer, &tokenizer.class_definition().name(), "hasMoreTokens", "()Z", ())
            .await?
    );
    assert!(
        jvm.invoke_virtual::<_, bool>(&tokenizer, &tokenizer.class_definition().name(), "hasMoreElements", "()Z", ())
            .await?
    );
    assert_eq!(
        jvm.invoke_virtual::<_, i32>(&tokenizer, &tokenizer.class_definition().name(), "countTokens", "()I", ())
            .await?,
        2
    );

    let first: ClassInstanceRef<String> = jvm
        .invoke_virtual(&tokenizer, &tokenizer.class_definition().name(), "nextToken", "()Ljava/lang/String;", ())
        .await?;
    assert_eq!(JavaLangString::to_rust_string(&jvm, &first).await?, "a");

    let semicolon = JavaLangString::from_rust_string(&jvm, ";").await?;
    let second: ClassInstanceRef<String> = jvm
        .invoke_virtual(
            &tokenizer,
            &tokenizer.class_definition().name(),
            "nextToken",
            "(Ljava/lang/String;)Ljava/lang/String;",
            (semicolon,),
        )
        .await?;
    assert_eq!(JavaLangString::to_rust_string(&jvm, &second).await?, ",b");
    assert_eq!(
        jvm.invoke_virtual::<_, i32>(&tokenizer, &tokenizer.class_definition().name(), "countTokens", "()I", ())
            .await?,
        1
    );

    let last: ClassInstanceRef<Object> = jvm
        .invoke_virtual(
            &tokenizer,
            &tokenizer.class_definition().name(),
            "nextElement",
            "()Ljava/lang/Object;",
            (),
        )
        .await?;
    assert!(jvm.is_instance(&**last, "java/lang/String"));
    assert_eq!(JavaLangString::to_rust_string(&jvm, &last).await?, "c");
    assert!(
        !jvm.invoke_virtual::<_, bool>(&tokenizer, &tokenizer.class_definition().name(), "hasMoreTokens", "()Z", ())
            .await?
    );

    let exhausted: Result<ClassInstanceRef<String>> = jvm
        .invoke_virtual(&tokenizer, &tokenizer.class_definition().name(), "nextToken", "()Ljava/lang/String;", ())
        .await;
    let Err(JavaError::JavaException(exception)) = exhausted else {
        panic!("exhausted tokenizer must throw NoSuchElementException");
    };
    assert!(jvm.is_instance(&*exception, "java/util/NoSuchElementException"));

    let input = JavaLangString::from_rust_string(&jvm, "a,,b").await?;
    let comma = JavaLangString::from_rust_string(&jvm, ",").await?;
    let tokenizer = jvm
        .new_class(
            "java/util/StringTokenizer",
            "(Ljava/lang/String;Ljava/lang/String;Z)V",
            (input, comma, true),
        )
        .await?;
    let mut tokens = Vec::new();
    while jvm
        .invoke_virtual::<_, bool>(&tokenizer, &tokenizer.class_definition().name(), "hasMoreElements", "()Z", ())
        .await?
    {
        let token: ClassInstanceRef<String> = jvm
            .invoke_virtual(
                &tokenizer,
                &tokenizer.class_definition().name(),
                "nextElement",
                "()Ljava/lang/Object;",
                (),
            )
            .await?;
        tokens.push(JavaLangString::to_rust_string(&jvm, &token).await?);
    }
    assert_eq!(tokens, ["a", ",", ",", "b"]);

    Ok(())
}

#[tokio::test]
async fn tok_03_next_token_shares_input_value() -> Result<()> {
    let jvm = test_jvm().await?;
    let input = JavaLangString::from_rust_string(&jvm, " one two").await?;
    let tokenizer = jvm
        .new_class("java/util/StringTokenizer", "(Ljava/lang/String;)V", (input.clone(),))
        .await?;

    let input_value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&input, "java/lang/String", "value", "[C").await?;
    for (expected, offset) in [("one", 1), ("two", 5)] {
        let token: ClassInstanceRef<String> = jvm
            .invoke_virtual(&tokenizer, &tokenizer.class_definition().name(), "nextToken", "()Ljava/lang/String;", ())
            .await?;
        assert_eq!(JavaLangString::to_rust_string(&jvm, &token).await?, expected);

        let token_value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&token, "java/lang/String", "value", "[C").await?;
        assert_eq!(input_value.identity(), token_value.identity());
        assert_eq!(jvm.get_field::<i32>(&token, "java/lang/String", "offset", "I").await?, offset);
        assert_eq!(jvm.get_field::<i32>(&token, "java/lang/String", "count", "I").await?, 3);
    }

    Ok(())
}

#[tokio::test]
async fn tok_04_substring_input_composes_offsets_and_shares_root_value() -> Result<()> {
    let jvm = test_jvm().await?;
    let root = JavaLangString::from_rust_string(&jvm, "xx one two yy").await?;
    let input: ClassInstanceRef<String> = jvm
        .invoke_virtual(&root, &root.class_definition().name(), "substring", "(II)Ljava/lang/String;", (3, 10))
        .await?;
    assert_eq!(JavaLangString::to_rust_string(&jvm, &input).await?, "one two");

    let root_value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&root, "java/lang/String", "value", "[C").await?;

    let tokenizer = jvm
        .new_class("java/util/StringTokenizer", "(Ljava/lang/String;)V", (input.clone(),))
        .await?;
    assert_eq!(
        jvm.get_field::<i32>(&tokenizer, "java/util/StringTokenizer", "maxPosition", "I").await?,
        7
    );
    assert_eq!(
        jvm.invoke_virtual::<_, i32>(&tokenizer, &tokenizer.class_definition().name(), "countTokens", "()I", ())
            .await?,
        2
    );
    for (expected, offset) in [("one", 3), ("two", 7)] {
        let token: ClassInstanceRef<String> = jvm
            .invoke_virtual(&tokenizer, &tokenizer.class_definition().name(), "nextToken", "()Ljava/lang/String;", ())
            .await?;
        assert_eq!(JavaLangString::to_rust_string(&jvm, &token).await?, expected);

        let token_value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&token, "java/lang/String", "value", "[C").await?;
        assert_eq!(root_value.identity(), token_value.identity());
        assert_eq!(jvm.get_field::<i32>(&token, "java/lang/String", "offset", "I").await?, offset);
        assert_eq!(jvm.get_field::<i32>(&token, "java/lang/String", "count", "I").await?, 3);
    }
    assert!(
        !jvm.invoke_virtual::<_, bool>(&tokenizer, &tokenizer.class_definition().name(), "hasMoreTokens", "()Z", ())
            .await?
    );

    let space = JavaLangString::from_rust_string(&jvm, " ").await?;
    let tokenizer = jvm
        .new_class(
            "java/util/StringTokenizer",
            "(Ljava/lang/String;Ljava/lang/String;Z)V",
            (input, space, true),
        )
        .await?;
    assert_eq!(
        jvm.invoke_virtual::<_, i32>(&tokenizer, &tokenizer.class_definition().name(), "countTokens", "()I", ())
            .await?,
        3
    );
    let mut tokens = Vec::new();
    while jvm
        .invoke_virtual::<_, bool>(&tokenizer, &tokenizer.class_definition().name(), "hasMoreTokens", "()Z", ())
        .await?
    {
        let token: ClassInstanceRef<String> = jvm
            .invoke_virtual(&tokenizer, &tokenizer.class_definition().name(), "nextToken", "()Ljava/lang/String;", ())
            .await?;
        tokens.push(JavaLangString::to_rust_string(&jvm, &token).await?);
    }
    assert_eq!(tokens, ["one", " ", "two"]);

    Ok(())
}