rustjava-runtime 0.3.2

A Java standard library implementation for RustJava
Documentation
use jvm::{ClassInstanceRef, JavaError, Result, runtime::JavaLangString};
use rustjava_runtime::classes::java::lang::{Integer, Object, String};

use test_utils::test_jvm;

#[tokio::test]
async fn test_parse_int() -> Result<()> {
    let jvm = test_jvm().await?;

    let string = JavaLangString::from_rust_string(&jvm, "42").await?;
    assert_eq!(
        42i32,
        jvm.invoke_static("java/lang/Integer", "parseInt", "(Ljava/lang/String;)I", (string,))
            .await?
    );

    let boxed: ClassInstanceRef<Integer> = jvm.invoke_static("java/lang/Integer", "valueOf", "(I)Ljava/lang/Integer;", (42,)).await?;
    assert_eq!(
        jvm.invoke_virtual::<_, i32>(&boxed, "java/lang/Integer", "intValue", "()I", ()).await?,
        42
    );

    Ok(())
}

#[tokio::test]
async fn test_parse_int_invalid() -> Result<()> {
    let jvm = test_jvm().await?;

    let string = JavaLangString::from_rust_string(&jvm, "abc").await?;
    let result: Result<i32> = jvm
        .invoke_static("java/lang/Integer", "parseInt", "(Ljava/lang/String;)I", (string,))
        .await;

    let Err(JavaError::JavaException(exception)) = result else {
        panic!("Expected JavaException, got {:?}", result);
    };
    assert!(jvm.is_instance(&*exception, "java/lang/NumberFormatException"));

    Ok(())
}

#[tokio::test]
async fn test_integer_strict_api() -> Result<()> {
    let jvm = test_jvm().await?;

    for (text, radix, expected) in [
        ("7fffffff", 16, i32::MAX),
        ("-80000000", 16, i32::MIN),
        ("z", 36, 35),
        ("\u{ff21}", 16, 10),
        ("\u{0661}\u{0662}\u{0663}", 10, 123),
    ] {
        let string = JavaLangString::from_rust_string(&jvm, text).await?;
        let value: i32 = jvm
            .invoke_static("java/lang/Integer", "parseInt", "(Ljava/lang/String;I)I", (string, radix))
            .await?;
        assert_eq!(value, expected);
    }
    for (text, radix, expected) in [
        ("-10000000000000000000000000000000", 2, i32::MIN),
        ("1111111111111111111111111111111", 2, i32::MAX),
        ("-2147483648", 10, i32::MIN),
        ("2147483647", 10, i32::MAX),
        ("-zik0zk", 36, i32::MIN),
        ("zik0zj", 36, i32::MAX),
    ] {
        let text = JavaLangString::from_rust_string(&jvm, text).await?;
        let parsed: i32 = jvm
            .invoke_static("java/lang/Integer", "parseInt", "(Ljava/lang/String;I)I", (text, radix))
            .await?;
        assert_eq!(parsed, expected);
    }

    let decoded_name = JavaLangString::from_rust_string(&jvm, "-0x80000000").await?;
    let decoded: ClassInstanceRef<Integer> = jvm
        .invoke_static("java/lang/Integer", "decode", "(Ljava/lang/String;)Ljava/lang/Integer;", (decoded_name,))
        .await?;
    assert_eq!(
        jvm.invoke_virtual::<_, i32>(&decoded, "java/lang/Integer", "intValue", "()I", ()).await?,
        i32::MIN
    );

    for (method, expected) in [
        ("toBinaryString", "11111111111111111111111111111111"),
        ("toOctalString", "37777777777"),
        ("toHexString", "ffffffff"),
    ] {
        let formatted: ClassInstanceRef<String> = jvm.invoke_static("java/lang/Integer", method, "(I)Ljava/lang/String;", (-1,)).await?;
        assert_eq!(JavaLangString::to_rust_string(&jvm, &formatted).await?, expected);
    }

    let left = jvm.new_class("java/lang/Integer", "(I)V", (1,)).await?;
    let right = jvm.new_class("java/lang/Integer", "(I)V", (2,)).await?;
    assert_eq!(
        jvm.invoke_virtual::<_, i32>(
            &left,
            &left.class_definition().name(),
            "compareTo",
            "(Ljava/lang/Integer;)I",
            (right.clone(),)
        )
        .await?,
        -1
    );
    assert_eq!(
        jvm.invoke_virtual::<_, i32>(
            &left,
            &left.class_definition().name(),
            "compareTo",
            "(Ljava/lang/Object;)I",
            (right.clone(),)
        )
        .await?,
        -1
    );
    assert!(
        !jvm.invoke_virtual::<_, bool>(
            &left,
            &left.class_definition().name(),
            "equals",
            "(Ljava/lang/Object;)Z",
            (right.clone(),)
        )
        .await?
    );
    assert_eq!(
        jvm.invoke_virtual::<_, i32>(&left, &left.class_definition().name(), "hashCode", "()I", ())
            .await?,
        1
    );

    let typed_null_result: Result<i32> = jvm
        .invoke_virtual(&left, &left.class_definition().name(), "compareTo", "(Ljava/lang/Integer;)I", (None,))
        .await;
    let Err(JavaError::JavaException(exception)) = typed_null_result else {
        panic!("Integer typed compare null must throw NPE");
    };
    assert!(jvm.is_instance(&*exception, "java/lang/NullPointerException"));

    let null_result: Result<i32> = jvm
        .invoke_virtual(&left, &left.class_definition().name(), "compareTo", "(Ljava/lang/Object;)I", (None,))
        .await;
    let Err(JavaError::JavaException(exception)) = null_result else {
        panic!("Integer raw compare null must throw NPE");
    };
    assert!(jvm.is_instance(&*exception, "java/lang/NullPointerException"));

    let object = jvm.new_class("java/lang/Object", "()V", ()).await?;
    let wrong_result: Result<i32> = jvm
        .invoke_virtual(&left, &left.class_definition().name(), "compareTo", "(Ljava/lang/Object;)I", (object,))
        .await;
    let Err(JavaError::JavaException(exception)) = wrong_result else {
        panic!("Integer raw compare wrong type must throw CCE");
    };
    assert!(jvm.is_instance(&*exception, "java/lang/ClassCastException"));

    let min = jvm.get_static_field::<i32>("java/lang/Integer", "MIN_VALUE", "I").await?;
    let max = jvm.get_static_field::<i32>("java/lang/Integer", "MAX_VALUE", "I").await?;
    assert_eq!((min, max), (i32::MIN, i32::MAX));
    let typ = jvm.get_static_field("java/lang/Integer", "TYPE", "Ljava/lang/Class;").await?;
    let name: ClassInstanceRef<String> = jvm
        .invoke_virtual(&typ, &typ.class_definition().name(), "getName", "()Ljava/lang/String;", ())
        .await?;
    assert_eq!(JavaLangString::to_rust_string(&jvm, &name).await?, "int");
    assert!(
        jvm.invoke_virtual::<_, bool>(&typ, &typ.class_definition().name(), "isPrimitive", "()Z", ())
            .await?
    );
    let _: () = jvm.invoke_static("java/lang/System", "gc", "()V", ()).await?;
    let typ = jvm.get_static_field("java/lang/Integer", "TYPE", "Ljava/lang/Class;").await?;
    assert!(
        jvm.invoke_virtual::<_, bool>(&typ, &typ.class_definition().name(), "isPrimitive", "()Z", ())
            .await?
    );
    Ok(())
}

#[tokio::test]
async fn test_integer_rejects_invalid_forms_and_uses_property_defaults() -> Result<()> {
    let jvm = test_jvm().await?;

    for (text, radix) in [
        ("", 10),
        ("+", 10),
        ("-", 10),
        (" 1", 10),
        ("2147483648", 10),
        ("-2147483649", 10),
        ("1", 1),
        ("1", 37),
    ] {
        let text = JavaLangString::from_rust_string(&jvm, text).await?;
        let result: Result<i32> = jvm
            .invoke_static("java/lang/Integer", "parseInt", "(Ljava/lang/String;I)I", (text, radix))
            .await;
        let Err(JavaError::JavaException(exception)) = result else {
            panic!("Integer.parseInt must reject invalid input");
        };
        assert!(jvm.is_instance(&*exception, "java/lang/NumberFormatException"));
    }

    let misplaced_sign = JavaLangString::from_rust_string(&jvm, "0x-1").await?;
    let result: Result<ClassInstanceRef<Integer>> = jvm
        .invoke_static(
            "java/lang/Integer",
            "decode",
            "(Ljava/lang/String;)Ljava/lang/Integer;",
            (misplaced_sign,),
        )
        .await;
    let Err(JavaError::JavaException(exception)) = result else {
        panic!("Integer.decode must reject a sign after the radix prefix");
    };
    assert!(jvm.is_instance(&*exception, "java/lang/NumberFormatException"));

    for (text, expected) in [("#7f", 127i32), ("0177", 127i32)] {
        let text = JavaLangString::from_rust_string(&jvm, text).await?;
        let decoded: ClassInstanceRef<Integer> = jvm
            .invoke_static("java/lang/Integer", "decode", "(Ljava/lang/String;)Ljava/lang/Integer;", (text,))
            .await?;
        assert_eq!(
            jvm.invoke_virtual::<_, i32>(&decoded, "java/lang/Integer", "intValue", "()I", ()).await?,
            expected
        );
    }

    let key = JavaLangString::from_rust_string(&jvm, "rustjava.test.integer").await?;
    let value = JavaLangString::from_rust_string(&jvm, "0x2a").await?;
    let _: ClassInstanceRef<Object> = jvm
        .invoke_static(
            "java/lang/System",
            "setProperty",
            "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;",
            (key.clone(), value),
        )
        .await?;
    let property: ClassInstanceRef<Integer> = jvm
        .invoke_static(
            "java/lang/Integer",
            "getInteger",
            "(Ljava/lang/String;)Ljava/lang/Integer;",
            (key.clone(),),
        )
        .await?;
    assert_eq!(
        jvm.invoke_virtual::<_, i32>(&property, "java/lang/Integer", "intValue", "()I", ())
            .await?,
        42
    );

    let invalid = JavaLangString::from_rust_string(&jvm, "not-an-integer").await?;
    let _: ClassInstanceRef<Object> = jvm
        .invoke_static(
            "java/lang/System",
            "setProperty",
            "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;",
            (key.clone(), invalid),
        )
        .await?;
    let property: ClassInstanceRef<Integer> = jvm
        .invoke_static(
            "java/lang/Integer",
            "getInteger",
            "(Ljava/lang/String;I)Ljava/lang/Integer;",
            (key.clone(), 17),
        )
        .await?;
    assert_eq!(
        jvm.invoke_virtual::<_, i32>(&property, "java/lang/Integer", "intValue", "()I", ())
            .await?,
        17
    );

    let default = jvm.new_class("java/lang/Integer", "(I)V", (23,)).await?;
    let property: ClassInstanceRef<Integer> = jvm
        .invoke_static(
            "java/lang/Integer",
            "getInteger",
            "(Ljava/lang/String;Ljava/lang/Integer;)Ljava/lang/Integer;",
            (key, default),
        )
        .await?;
    assert_eq!(
        jvm.invoke_virtual::<_, i32>(&property, "java/lang/Integer", "intValue", "()I", ())
            .await?,
        23
    );

    Ok(())
}