Fix array assignability and reader progress

Author: dlunch

java_runtime/src/classes/java/io/input_stream_reader.rs

@@ -120,9 +120,9 @@ impl InputStreamReader {
             return Ok(0);
         }
 
-        let write_buf_size: i32 = jvm.get_field(&this, "writeBufSize", "I").await?;
+        let mut write_buf_size: i32 = jvm.get_field(&this, "writeBufSize", "I").await?;
 
-        if write_buf_size < length {
+        while write_buf_size < length {
             let read_buf: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "readBuf", "[B").await?;
             let read_buf_size: i32 = jvm.get_field(&this, "readBufSize", "I").await?;
 
@@ -202,14 +202,18 @@ impl InputStreamReader {
 
             // add to writeBuf
             let mut write_buf = jvm.get_field(&this, "writeBuf", "[C").await?;
-            let write_buf_size: i32 = jvm.get_field(&this, "writeBufSize", "I").await?;
+            let buffered_chars: i32 = jvm.get_field(&this, "writeBufSize", "I").await?;
             jvm.store_array(
                 &mut write_buf,
-                write_buf_size as _,
+                buffered_chars as _,
                 cast_slice::<u16, JavaChar>(&decoded[..wrote]).to_vec(),
             )
             .await?;
-            jvm.put_field(&mut this, "writeBufSize", "I", write_buf_size + wrote as i32).await?;
+            write_buf_size = buffered_chars + wrote as i32;
+            jvm.put_field(&mut this, "writeBufSize", "I", write_buf_size).await?;
+            if write_buf_size > 0 {
+                break;
+            }
         }
 
         let write_buf: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "writeBuf", "[C").await?;

java_runtime/src/classes/java/lang/class.rs

@@ -3,7 +3,7 @@ use alloc::vec;
 use java_class_proto::{JavaFieldProto, JavaMethodProto};
 use java_constants::{ClassAccessFlags, MethodAccessFlags};
 use jvm::{
-    ClassInstanceRef, Jvm, Result,
+    ClassInstanceRef, JavaType, Jvm, Result,
     runtime::{JavaLangClass, JavaLangClassLoader, JavaLangString},
 };
 
@@ -170,10 +170,7 @@ impl Class {
             return Ok(class_name == other_name);
         }
 
-        let rust_class = JavaLangClass::to_rust_class(jvm, &this).await?;
-        let other_rust_class = JavaLangClass::to_rust_class(jvm, &other).await?;
-
-        Ok(jvm.is_inherited_from(&*other_rust_class, &rust_class.name()))
+        Ok(jvm.is_type_assignable(&JavaType::from_class_name(&other_name), &JavaType::from_class_name(&class_name)))
     }
 
     async fn get_resource_as_stream(

java_runtime/tests/classes/java/io/test_input_stream_reader.rs

@@ -1,9 +1,76 @@
-use alloc::{vec, vec::Vec};
+use alloc::{boxed::Box, collections::BTreeMap, vec, vec::Vec};
 
+use java_class_proto::{JavaFieldProto, JavaMethodProto};
 use java_runtime::classes::java::lang::Object;
-use jvm::{ClassInstanceRef, JavaChar, JavaError, Result, runtime::JavaLangString};
-
-use test_utils::test_jvm;
+use java_runtime::{RuntimeClassProto, RuntimeContext};
+use jvm::{Array, ClassInstanceRef, JavaChar, JavaError, Jvm, Result, runtime::JavaLangString};
+use jvm_rust::ClassDefinitionImpl;
+
+use test_utils::{TestRuntime, create_test_jvm, test_jvm};
+
+struct OneByteInputStream;
+
+impl OneByteInputStream {
+    fn as_proto() -> RuntimeClassProto {
+        RuntimeClassProto {
+            name: "OneByteInputStream",
+            parent_class: Some("java/io/InputStream"),
+            interfaces: vec![],
+            methods: vec![
+                JavaMethodProto::new("<init>", "([B)V", Self::init, Default::default()),
+                JavaMethodProto::new("read", "()I", Self::read, Default::default()),
+                JavaMethodProto::new("read", "([BII)I", Self::read_offset_length, Default::default()),
+            ],
+            fields: vec![
+                JavaFieldProto::new("data", "[B", Default::default()),
+                JavaFieldProto::new("position", "I", Default::default()),
+            ],
+            access_flags: Default::default(),
+        }
+    }
+
+    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, data: ClassInstanceRef<Array<i8>>) -> Result<()> {
+        let _: () = jvm.invoke_special(&this, "java/io/InputStream", "<init>", "()V", ()).await?;
+        jvm.put_field(&mut this, "data", "[B", data).await?;
+        jvm.put_field(&mut this, "position", "I", 0).await?;
+
+        Ok(())
+    }
+
+    async fn read(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<i32> {
+        let data: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "data", "[B").await?;
+        let position: i32 = jvm.get_field(&this, "position", "I").await?;
+        if position == jvm.array_length(&data).await? as i32 {
+            return Ok(-1);
+        }
+
+        let value = jvm.load_array::<i8>(&data, position as usize, 1).await?[0];
+        jvm.put_field(&mut this, "position", "I", position + 1).await?;
+
+        Ok(value as u8 as i32)
+    }
+
+    async fn read_offset_length(
+        jvm: &Jvm,
+        _: &mut RuntimeContext,
+        this: ClassInstanceRef<Self>,
+        mut target: ClassInstanceRef<Array<i8>>,
+        offset: i32,
+        length: i32,
+    ) -> Result<i32> {
+        if length == 0 {
+            return Ok(0);
+        }
+
+        let value: i32 = jvm.invoke_virtual(&this, "read", "()I", ()).await?;
+        if value == -1 {
+            return Ok(-1);
+        }
+
+        jvm.store_array(&mut target, offset as usize, [value as i8]).await?;
+        Ok(1)
+    }
+}
 
 #[tokio::test]
 async fn test_isr() -> Result<()> {
@@ -55,6 +122,33 @@ async fn test_input_stream_reader_preserves_split_multibyte_and_buffered_eof() -
     Ok(())
 }
 
+#[tokio::test]
+async fn test_input_stream_reader_does_not_return_zero_for_split_multibyte_input() -> Result<()> {
+    let runtime = TestRuntime::new(BTreeMap::new());
+    let jvm = create_test_jvm(runtime.clone()).await?;
+    jvm.register_class(
+        Box::new(ClassDefinitionImpl::from_class_proto(
+            OneByteInputStream::as_proto(),
+            Box::new(runtime) as Box<_>,
+        )),
+        None,
+    )
+    .await?;
+
+    let value = "한";
+    let mut bytes = jvm.instantiate_array("B", value.len()).await?;
+    jvm.store_array(&mut bytes, 0, value.as_bytes().iter().map(|byte| *byte as i8)).await?;
+    let input = jvm.new_class("OneByteInputStream", "([B)V", (bytes,)).await?;
+    let reader = jvm.new_class("java/io/InputStreamReader", "(Ljava/io/InputStream;)V", (input,)).await?;
+    let chars = jvm.instantiate_array("C", 1).await?;
+
+    assert_eq!(jvm.invoke_virtual::<_, i32>(&reader, "read", "([CII)I", (chars.clone(), 0, 1)).await?, 1);
+    assert_eq!(jvm.load_array::<JavaChar>(&chars, 0, 1).await?, ['한' as JavaChar]);
+    assert_eq!(jvm.invoke_virtual::<_, i32>(&reader, "read", "([CII)I", (chars, 0, 1)).await?, -1);
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn test_input_stream_reader_rejects_unknown_encoding() -> Result<()> {
     let jvm = test_jvm().await?;

java_runtime/tests/classes/java/lang/test_class.rs

@@ -41,6 +41,42 @@ async fn test_is_assignable_from() -> Result<()> {
         .await?;
     assert!(!result);
 
+    let string_array_class = jvm.resolve_class("[Ljava/lang/String;").await?.java_class();
+    let object_array_class = jvm.resolve_class("[Ljava/lang/Object;").await?.java_class();
+    let cloneable_class = jvm.resolve_class("java/lang/Cloneable").await?.java_class();
+    let serializable_class = jvm.resolve_class("java/io/Serializable").await?.java_class();
+
+    assert!(
+        jvm.invoke_virtual::<_, bool>(
+            &object_array_class,
+            "isAssignableFrom",
+            "(Ljava/lang/Class;)Z",
+            (string_array_class.clone(),),
+        )
+        .await?
+    );
+    assert!(
+        !jvm.invoke_virtual::<_, bool>(&string_array_class, "isAssignableFrom", "(Ljava/lang/Class;)Z", (object_array_class,),)
+            .await?
+    );
+    assert!(
+        jvm.invoke_virtual::<_, bool>(&object_class, "isAssignableFrom", "(Ljava/lang/Class;)Z", (string_array_class.clone(),),)
+            .await?
+    );
+    assert!(
+        jvm.invoke_virtual::<_, bool>(
+            &cloneable_class,
+            "isAssignableFrom",
+            "(Ljava/lang/Class;)Z",
+            (string_array_class.clone(),),
+        )
+        .await?
+    );
+    assert!(
+        jvm.invoke_virtual::<_, bool>(&serializable_class, "isAssignableFrom", "(Ljava/lang/Class;)Z", (string_array_class,),)
+            .await?
+    );
+
     Ok(())
 }
 

jvm/src/jvm.rs

@@ -631,7 +631,7 @@ impl Jvm {
     }
 
     // JVMS 4.10.3 subtyping, including array covariance
-    fn is_type_assignable(&self, source: &JavaType, target: &JavaType) -> bool {
+    pub fn is_type_assignable(&self, source: &JavaType, target: &JavaType) -> bool {
         if source == target {
             return true;
         }