rustjava-runtime 0.1.1

A Java standard library implementation for RustJava
Documentation
use alloc::{boxed::Box, collections::BTreeMap, vec};

use jvm::{Array, ClassInstanceRef, JavaError, Jvm, Result};
use jvm_bytecode::ClassDefinitionImpl;
use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
use rustjava_runtime::{RuntimeClassProto, RuntimeContext, classes::java::io::OutputStream};
use test_utils::{TestRuntime, create_test_jvm};

struct CloseProbeOutputStream;

impl CloseProbeOutputStream {
    fn as_proto() -> RuntimeClassProto {
        RuntimeClassProto {
            name: "CloseProbeOutputStream",
            parent_class: Some("java/io/OutputStream"),
            interfaces: vec![],
            methods: vec![
                JavaMethodProto::new("<init>", "(II)V", Self::init, MethodAccessFlags::PUBLIC),
                JavaMethodProto::new("write", "(I)V", Self::write, MethodAccessFlags::PUBLIC),
                JavaMethodProto::new("flush", "()V", Self::flush, MethodAccessFlags::PUBLIC),
                JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
            ],
            fields: vec![
                JavaFieldProto::new("flushMode", "I", FieldAccessFlags::PUBLIC),
                JavaFieldProto::new("closeMode", "I", FieldAccessFlags::PUBLIC),
                JavaFieldProto::new("bytesWritten", "I", FieldAccessFlags::PUBLIC),
                JavaFieldProto::new("flushCalls", "I", FieldAccessFlags::PUBLIC),
                JavaFieldProto::new("closeCalls", "I", FieldAccessFlags::PUBLIC),
            ],
            access_flags: ClassAccessFlags::PUBLIC,
        }
    }

    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, flush_mode: i32, close_mode: i32) -> Result<()> {
        let _: () = jvm.invoke_special(&this, "java/io/OutputStream", "<init>", "()V", ()).await?;
        jvm.put_field(&mut this, "flushMode", "I", flush_mode).await?;
        jvm.put_field(&mut this, "closeMode", "I", close_mode).await?;
        jvm.put_field(&mut this, "bytesWritten", "I", 0).await?;
        jvm.put_field(&mut this, "flushCalls", "I", 0).await?;
        jvm.put_field(&mut this, "closeCalls", "I", 0).await
    }

    async fn write(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, _: i32) -> Result<()> {
        let count: i32 = jvm.get_field(&this, "bytesWritten", "I").await?;
        jvm.put_field(&mut this, "bytesWritten", "I", count + 1).await
    }

    async fn flush(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
        let calls: i32 = jvm.get_field(&this, "flushCalls", "I").await?;
        jvm.put_field(&mut this, "flushCalls", "I", calls + 1).await?;
        match jvm.get_field::<i32>(&this, "flushMode", "I").await? {
            1 => Err(jvm.exception("java/io/IOException", "flush failed").await),
            2 => Err(jvm.exception("java/lang/IllegalStateException", "flush failed").await),
            _ => Ok(()),
        }
    }

    async fn close(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
        let calls: i32 = jvm.get_field(&this, "closeCalls", "I").await?;
        jvm.put_field(&mut this, "closeCalls", "I", calls + 1).await?;
        match jvm.get_field::<i32>(&this, "closeMode", "I").await? {
            1 => Err(jvm.exception("java/io/IOException", "close failed").await),
            2 => Err(jvm.exception("java/lang/IllegalStateException", "close failed").await),
            _ => Ok(()),
        }
    }
}

struct FlushOverrideBufferedOutputStream;

impl FlushOverrideBufferedOutputStream {
    fn as_proto() -> RuntimeClassProto {
        RuntimeClassProto {
            name: "FlushOverrideBufferedOutputStream",
            parent_class: Some("java/io/BufferedOutputStream"),
            interfaces: vec![],
            methods: vec![
                JavaMethodProto::new("<init>", "(Ljava/io/OutputStream;II)V", Self::init, MethodAccessFlags::PUBLIC),
                JavaMethodProto::new("flush", "()V", Self::flush, MethodAccessFlags::PUBLIC),
            ],
            fields: vec![
                JavaFieldProto::new("flushMode", "I", FieldAccessFlags::PUBLIC),
                JavaFieldProto::new("flushCalls", "I", FieldAccessFlags::PUBLIC),
            ],
            access_flags: ClassAccessFlags::PUBLIC,
        }
    }

    async fn init(
        jvm: &Jvm,
        _: &mut RuntimeContext,
        mut this: ClassInstanceRef<Self>,
        out: ClassInstanceRef<OutputStream>,
        size: i32,
        flush_mode: i32,
    ) -> Result<()> {
        let _: () = jvm
            .invoke_special(&this, "java/io/BufferedOutputStream", "<init>", "(Ljava/io/OutputStream;I)V", (out, size))
            .await?;
        jvm.put_field(&mut this, "flushMode", "I", flush_mode).await?;
        jvm.put_field(&mut this, "flushCalls", "I", 0).await
    }

    async fn flush(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
        let calls: i32 = jvm.get_field(&this, "flushCalls", "I").await?;
        jvm.put_field(&mut this, "flushCalls", "I", calls + 1).await?;
        match jvm.get_field::<i32>(&this, "flushMode", "I").await? {
            1 => Err(jvm.exception("java/io/IOException", "override flush failed").await),
            2 => Err(jvm.exception("java/lang/IllegalStateException", "override flush failed").await),
            _ => jvm.invoke_special(&this, "java/io/BufferedOutputStream", "flush", "()V", ()).await,
        }
    }
}

async fn output_stream_close_jvm() -> Result<Jvm> {
    let runtime = TestRuntime::new(BTreeMap::new());
    let jvm = create_test_jvm(runtime.clone()).await?;
    jvm.register_class(
        Box::new(ClassDefinitionImpl::from_class_proto(
            CloseProbeOutputStream::as_proto(),
            Box::new(runtime.clone()) as Box<_>,
        )),
        None,
    )
    .await?;
    jvm.register_class(
        Box::new(ClassDefinitionImpl::from_class_proto(
            FlushOverrideBufferedOutputStream::as_proto(),
            Box::new(runtime) as Box<_>,
        )),
        None,
    )
    .await?;
    Ok(jvm)
}

#[tokio::test]
async fn buffered_output_stream_inherited_close_dispatches_virtual_flush() -> Result<()> {
    let jvm = output_stream_close_jvm().await?;
    let backing: ClassInstanceRef<CloseProbeOutputStream> = jvm.new_class("CloseProbeOutputStream", "(II)V", (0, 0)).await?.into();
    let output: ClassInstanceRef<OutputStream> = backing.instance.clone().into();
    let stream: ClassInstanceRef<FlushOverrideBufferedOutputStream> = jvm
        .new_class("FlushOverrideBufferedOutputStream", "(Ljava/io/OutputStream;II)V", (output, 4, 0))
        .await?
        .into();
    let buffer: ClassInstanceRef<Array<i8>> = jvm.get_field(&stream, "buf", "[B").await?;

    let _: () = jvm
        .invoke_virtual(&stream, "FlushOverrideBufferedOutputStream", "write", "(I)V", (7,))
        .await?;
    let _: () = jvm
        .invoke_virtual(&stream, "FlushOverrideBufferedOutputStream", "close", "()V", ())
        .await?;

    assert_eq!(jvm.get_field::<i32>(&stream, "flushCalls", "I").await?, 1);
    assert_eq!(jvm.get_field::<i32>(&backing, "bytesWritten", "I").await?, 1);
    assert_eq!(jvm.get_field::<i32>(&backing, "flushCalls", "I").await?, 1);
    assert_eq!(jvm.get_field::<i32>(&backing, "closeCalls", "I").await?, 1);
    assert_eq!(jvm.get_field::<i32>(&stream, "count", "I").await?, 0);
    let retained_buffer: ClassInstanceRef<Array<i8>> = jvm.get_field(&stream, "buf", "[B").await?;
    assert_eq!(retained_buffer.identity(), buffer.identity());
    let closed_output: ClassInstanceRef<OutputStream> = jvm.get_field(&stream, "out", "Ljava/io/OutputStream;").await?;
    assert!(closed_output.is_null());

    let _: () = jvm
        .invoke_virtual(&stream, "FlushOverrideBufferedOutputStream", "close", "()V", ())
        .await?;
    assert_eq!(jvm.get_field::<i32>(&stream, "flushCalls", "I").await?, 1);
    assert_eq!(jvm.get_field::<i32>(&backing, "closeCalls", "I").await?, 1);
    Ok(())
}

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

    let backing: ClassInstanceRef<CloseProbeOutputStream> = jvm.new_class("CloseProbeOutputStream", "(II)V", (0, 0)).await?.into();
    let output: ClassInstanceRef<OutputStream> = backing.instance.clone().into();
    let stream: ClassInstanceRef<FlushOverrideBufferedOutputStream> = jvm
        .new_class("FlushOverrideBufferedOutputStream", "(Ljava/io/OutputStream;II)V", (output, 4, 1))
        .await?
        .into();
    let _: () = jvm
        .invoke_virtual(&stream, "FlushOverrideBufferedOutputStream", "write", "(I)V", (1,))
        .await?;
    let _: () = jvm
        .invoke_virtual(&stream, "FlushOverrideBufferedOutputStream", "close", "()V", ())
        .await?;
    assert_eq!(jvm.get_field::<i32>(&stream, "flushCalls", "I").await?, 1);
    assert_eq!(jvm.get_field::<i32>(&stream, "count", "I").await?, 1);
    assert_eq!(jvm.get_field::<i32>(&backing, "bytesWritten", "I").await?, 0);
    assert_eq!(jvm.get_field::<i32>(&backing, "closeCalls", "I").await?, 1);
    let closed_output: ClassInstanceRef<OutputStream> = jvm.get_field(&stream, "out", "Ljava/io/OutputStream;").await?;
    assert!(closed_output.is_null());

    let backing: ClassInstanceRef<CloseProbeOutputStream> = jvm.new_class("CloseProbeOutputStream", "(II)V", (0, 0)).await?.into();
    let output: ClassInstanceRef<OutputStream> = backing.instance.clone().into();
    let stream: ClassInstanceRef<FlushOverrideBufferedOutputStream> = jvm
        .new_class("FlushOverrideBufferedOutputStream", "(Ljava/io/OutputStream;II)V", (output, 4, 2))
        .await?
        .into();
    let result: Result<()> = jvm.invoke_virtual(&stream, "FlushOverrideBufferedOutputStream", "close", "()V", ()).await;
    let Err(JavaError::JavaException(exception)) = result else {
        panic!("unchecked flush failure must escape inherited close");
    };
    assert!(jvm.is_instance(&*exception, "java/lang/IllegalStateException"));
    assert_eq!(jvm.get_field::<i32>(&backing, "closeCalls", "I").await?, 0);
    let closed_output: ClassInstanceRef<OutputStream> = jvm.get_field(&stream, "out", "Ljava/io/OutputStream;").await?;
    assert!(closed_output.is_null());

    let backing: ClassInstanceRef<CloseProbeOutputStream> = jvm.new_class("CloseProbeOutputStream", "(II)V", (0, 1)).await?.into();
    let output: ClassInstanceRef<OutputStream> = backing.instance.clone().into();
    let stream: ClassInstanceRef<FlushOverrideBufferedOutputStream> = jvm
        .new_class("FlushOverrideBufferedOutputStream", "(Ljava/io/OutputStream;II)V", (output, 4, 0))
        .await?
        .into();
    let _: () = jvm
        .invoke_virtual(&stream, "FlushOverrideBufferedOutputStream", "write", "(I)V", (1,))
        .await?;
    let result: Result<()> = jvm.invoke_virtual(&stream, "FlushOverrideBufferedOutputStream", "close", "()V", ()).await;
    let Err(JavaError::JavaException(exception)) = result else {
        panic!("backing close failure must escape inherited close");
    };
    assert!(jvm.is_instance(&*exception, "java/io/IOException"));
    assert_eq!(jvm.get_field::<i32>(&stream, "flushCalls", "I").await?, 1);
    assert_eq!(jvm.get_field::<i32>(&stream, "count", "I").await?, 0);
    assert_eq!(jvm.get_field::<i32>(&backing, "bytesWritten", "I").await?, 1);
    assert_eq!(jvm.get_field::<i32>(&backing, "flushCalls", "I").await?, 1);
    assert_eq!(jvm.get_field::<i32>(&backing, "closeCalls", "I").await?, 1);
    let closed_output: ClassInstanceRef<OutputStream> = jvm.get_field(&stream, "out", "Ljava/io/OutputStream;").await?;
    assert!(closed_output.is_null());

    Ok(())
}