rustjava-runtime 0.4.0

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

use bytemuck::cast_vec;

use jvm::{ClassInstanceRef, Result, runtime::JavaLangString};
use rustjava_runtime::classes::java::lang::String;

use test_utils::test_jvm;

#[tokio::test]
async fn null_input_arguments_and_delegates() -> Result<()> {
    use jvm::{JavaError, JavaValue};

    let jvm = test_jvm().await?;
    let input = jvm
        .new_class("java/io/DataInputStream", "(Ljava/io/InputStream;)V", [JavaValue::Object(None)])
        .await?;
    for (method, signature, args) in [
        ("available", "()I", vec![]),
        ("close", "()V", vec![]),
        ("reset", "()V", vec![]),
        ("markSupported", "()Z", vec![]),
        ("mark", "(I)V", vec![1.into()]),
        ("skip", "(J)J", vec![1i64.into()]),
        ("read", "()I", vec![]),
        ("read", "([B)I", vec![JavaValue::Object(None)]),
        ("read", "([BII)I", vec![JavaValue::Object(None), 0.into(), 1.into()]),
        ("readByte", "()B", vec![]),
        ("skipBytes", "(I)I", vec![1.into()]),
        ("readFully", "([B)V", vec![JavaValue::Object(None)]),
        ("readFully", "([BII)V", vec![JavaValue::Object(None), 0.into(), 0.into()]),
    ] {
        let result: Result<JavaValue> = jvm.invoke_virtual(&input, "java/io/DataInputStream", method, signature, args).await;
        let Err(JavaError::JavaException(exception)) = result else {
            panic!("{method}{signature} must throw NullPointerException");
        };
        assert!(jvm.is_instance(&*exception, "java/lang/NullPointerException"), "{method}{signature}");
    }
    let result: Result<JavaValue> = jvm
        .invoke_static(
            "java/io/DataInputStream",
            "readUTF",
            "(Ljava/io/DataInput;)Ljava/lang/String;",
            [JavaValue::Object(None)],
        )
        .await;
    let Err(JavaError::JavaException(exception)) = result else {
        panic!("static readUTF must reject null");
    };
    assert!(jvm.is_instance(&*exception, "java/lang/NullPointerException"));
    for amount in [0, -1] {
        let skipped: i32 = jvm
            .invoke_virtual(&input, "java/io/DataInputStream", "skipBytes", "(I)I", (amount,))
            .await?;
        assert_eq!(skipped, 0);
    }
    let empty = jvm.instantiate_array("B", 0).await?;
    let _: () = jvm
        .invoke_virtual(&input, "java/io/DataInputStream", "readFully", "([BII)V", (empty, 0, 0))
        .await?;
    Ok(())
}

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

    let data = vec![
        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
        0x18, 0x19, 0x1a, 0x1b, 0, 5, b'a', b'b', b'c', b'b', b'd',
    ];
    let data_len = data.len();

    let mut data_array = jvm.instantiate_array("B", data_len).await?;
    jvm.array_raw_buffer_mut(&mut data_array).await?.write(0, &data)?;

    let input_stream = jvm.new_class("java/io/ByteArrayInputStream", "([B)V", (data_array,)).await?;
    let data_input_stream = jvm
        .new_class("java/io/DataInputStream", "(Ljava/io/InputStream;)V", (input_stream,))
        .await?;

    let available: i32 = jvm
        .invoke_virtual(&data_input_stream, &data_input_stream.class_definition().name(), "available", "()I", ())
        .await?;
    assert_eq!(available, data_len as i32);

    let byte: i8 = jvm
        .invoke_virtual(&data_input_stream, &data_input_stream.class_definition().name(), "readByte", "()B", ())
        .await?;
    assert_eq!(byte, 0x01);

    let short: i16 = jvm
        .invoke_virtual(&data_input_stream, &data_input_stream.class_definition().name(), "readShort", "()S", ())
        .await?;
    assert_eq!(short, 0x0203);

    let int: i32 = jvm
        .invoke_virtual(&data_input_stream, &data_input_stream.class_definition().name(), "readInt", "()I", ())
        .await?;
    assert_eq!(int, 0x04050607);

    let long: i64 = jvm
        .invoke_virtual(&data_input_stream, &data_input_stream.class_definition().name(), "readLong", "()J", ())
        .await?;
    assert_eq!(long, 0x08090a0b0c0d0e0f);

    let float: f32 = jvm
        .invoke_virtual(&data_input_stream, &data_input_stream.class_definition().name(), "readFloat", "()F", ())
        .await?;
    assert_eq!(float, f32::from_be_bytes([0x10, 0x11, 0x12, 0x13]));

    let double: f64 = jvm
        .invoke_virtual(&data_input_stream, &data_input_stream.class_definition().name(), "readDouble", "()D", ())
        .await?;
    assert_eq!(double, f64::from_be_bytes([0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b]));

    let utf: ClassInstanceRef<String> = jvm
        .invoke_virtual(
            &data_input_stream,
            &data_input_stream.class_definition().name(),
            "readUTF",
            "()Ljava/lang/String;",
            (),
        )
        .await?;
    let string = JavaLangString::to_rust_string(&jvm, &utf).await?;
    assert_eq!(string, "abcbd");

    Ok(())
}

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

    let data = cast_vec(vec![
        0x81u8, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
        0x98, 0x99, 0x9a, 0x9b, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
    ]);
    let data_len = data.len();

    let mut data_array = jvm.instantiate_array("B", data_len).await?;
    jvm.array_raw_buffer_mut(&mut data_array).await?.write(0, &data)?;

    let input_stream = jvm.new_class("java/io/ByteArrayInputStream", "([B)V", (data_array,)).await?;
    let data_input_stream = jvm
        .new_class("java/io/DataInputStream", "(Ljava/io/InputStream;)V", (input_stream,))
        .await?;

    let available: i32 = jvm
        .invoke_virtual(&data_input_stream, &data_input_stream.class_definition().name(), "available", "()I", ())
        .await?;
    assert_eq!(available, data_len as i32);

    let byte: i8 = jvm
        .invoke_virtual(&data_input_stream, &data_input_stream.class_definition().name(), "readByte", "()B", ())
        .await?;
    assert_eq!(byte, i8::from_be_bytes([0x81]));

    let short: i16 = jvm
        .invoke_virtual(&data_input_stream, &data_input_stream.class_definition().name(), "readShort", "()S", ())
        .await?;
    assert_eq!(short, i16::from_be_bytes([0x82, 0x83]));

    let int: i32 = jvm
        .invoke_virtual(&data_input_stream, &data_input_stream.class_definition().name(), "readInt", "()I", ())
        .await?;
    assert_eq!(int, i32::from_be_bytes([0x84, 0x85, 0x86, 0x87]));

    let long: i64 = jvm
        .invoke_virtual(&data_input_stream, &data_input_stream.class_definition().name(), "readLong", "()J", ())
        .await?;
    assert_eq!(long, i64::from_be_bytes([0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f]));

    let float: f32 = jvm
        .invoke_virtual(&data_input_stream, &data_input_stream.class_definition().name(), "readFloat", "()F", ())
        .await?;
    assert_eq!(float, f32::from_be_bytes([0x90, 0x91, 0x92, 0x93]));

    let double: f64 = jvm
        .invoke_virtual(&data_input_stream, &data_input_stream.class_definition().name(), "readDouble", "()D", ())
        .await?;
    assert_eq!(double, f64::from_be_bytes([0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b]));

    let array = jvm.instantiate_array("B", 6).await?;
    let _: () = jvm
        .invoke_virtual(
            &data_input_stream,
            &data_input_stream.class_definition().name(),
            "readFully",
            "([B)V",
            (array.clone(),),
        )
        .await?;
    let mut buffer = vec![0; 6];
    jvm.array_raw_buffer(&array).await?.read(0, &mut buffer)?;
    assert_eq!(buffer, vec![0x10, 0x11, 0x12, 0x13, 0x14, 0x15]);

    let skipped: i32 = jvm
        .invoke_virtual(
            &data_input_stream,
            &data_input_stream.class_definition().name(),
            "skipBytes",
            "(I)I",
            (2,),
        )
        .await?;
    assert_eq!(skipped, 2);

    let short: i16 = jvm
        .invoke_virtual(&data_input_stream, &data_input_stream.class_definition().name(), "readShort", "()S", ())
        .await?;
    assert_eq!(short, i16::from_be_bytes([0x18, 0x19]));

    let available: i32 = jvm
        .invoke_virtual(&data_input_stream, &data_input_stream.class_definition().name(), "available", "()I", ())
        .await?;
    assert_eq!(available, 1);

    Ok(())
}

// covers InputStream.skip, which DataInputStream inherits
#[tokio::test]
async fn test_skip_past_eof() -> Result<()> {
    let jvm = test_jvm().await?;

    let mut buffer = jvm.instantiate_array("B", 5).await?;
    jvm.array_raw_buffer_mut(&mut buffer).await?.write(0, b"hello")?;

    let bais = jvm.new_class("java/io/ByteArrayInputStream", "([B)V", (buffer,)).await?;
    let dis = jvm.new_class("java/io/DataInputStream", "(Ljava/io/InputStream;)V", (bais,)).await?;

    let skipped: i64 = jvm.invoke_virtual(&dis, &dis.class_definition().name(), "skip", "(J)J", (10i64,)).await?;
    assert_eq!(skipped, 5);

    let read: i32 = jvm.invoke_virtual(&dis, &dis.class_definition().name(), "read", "()I", ()).await?;
    assert_eq!(read, -1);

    Ok(())
}