Implement DataOutputStream::writeUTF

Author: dlunch

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

@@ -21,8 +21,10 @@ impl DataOutputStream {
                 JavaMethodProto::new("write", "(I)V", Self::write, Default::default()),
                 JavaMethodProto::new("writeByte", "(I)V", Self::write, Default::default()),
                 JavaMethodProto::new("writeInt", "(I)V", Self::write_int, Default::default()),
+                JavaMethodProto::new("writeShort", "(I)V", Self::write_short, Default::default()),
                 JavaMethodProto::new("writeLong", "(J)V", Self::write_long, Default::default()),
                 JavaMethodProto::new("writeChars", "(Ljava/lang/String;)V", Self::write_chars, Default::default()),
+                JavaMethodProto::new("writeUTF", "(Ljava/lang/String;)V", Self::write_utf, Default::default()),
                 JavaMethodProto::new("close", "()V", Self::close, Default::default()),
                 JavaMethodProto::new("flush", "()V", Self::flush, Default::default()),
             ],
@@ -49,6 +51,19 @@ impl DataOutputStream {
         Ok(())
     }
 
+    async fn write_short(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, s: i32) -> Result<()> {
+        tracing::debug!("java.io.DataOutputStream::writeShort({:?}, {:?})", &this, s);
+
+        let bytes = (s as i16).to_be_bytes();
+        let mut byte_array = jvm.instantiate_array("B", bytes.len() as _).await?;
+        jvm.store_array(&mut byte_array, 0, cast_vec::<u8, i8>(bytes.to_vec())).await?;
+
+        let out = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?;
+        let _: () = jvm.invoke_virtual(&out, "write", "([B)V", (byte_array,)).await?;
+
+        Ok(())
+    }
+
     async fn write_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, i: i32) -> Result<()> {
         tracing::debug!("java.io.DataOutputStream::writeInt({:?}, {:?})", &this, i);
 
@@ -86,6 +101,21 @@ impl DataOutputStream {
         Ok(())
     }
 
+    async fn write_utf(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, s: ClassInstanceRef<JavaChar>) -> Result<()> {
+        tracing::debug!("java.io.DataOutputStream::writeUTF({:?}, {:?})", &this, &s);
+
+        // TODO handle modified utf-8
+        let bytes: ClassInstanceRef<Array<i8>> = jvm.invoke_virtual(&s, "getBytes", "()[B", ()).await?;
+        let length = jvm.array_length(&bytes).await?;
+
+        let _: () = jvm.invoke_virtual(&this, "writeShort", "(I)V", (length as i32,)).await?;
+
+        let out = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?;
+        let _: () = jvm.invoke_virtual(&out, "write", "([B)V", (bytes,)).await?;
+
+        Ok(())
+    }
+
     async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
         tracing::debug!("java.io.DataInputStream::close({:?})", &this);
 

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

@@ -2,7 +2,8 @@ use alloc::vec;
 
 use bytemuck::cast_vec;
 
-use jvm::Result;
+use java_runtime::classes::java::lang::String;
+use jvm::{ClassInstanceRef, Result, runtime::JavaLangString};
 
 use test_utils::test_jvm;
 
@@ -12,7 +13,7 @@ async fn test_data_input_stream() -> Result<()> {
 
     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,
+        0x18, 0x19, 0x1a, 0x1b, 0, 5, b'a', b'b', b'c', b'b', b'd',
     ];
     let data_len = data.len();
 
@@ -45,6 +46,10 @@ async fn test_data_input_stream() -> Result<()> {
     let double: f64 = jvm.invoke_virtual(&data_input_stream, "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, "readUTF", "()Ljava/lang/String;", ()).await?;
+    let string = JavaLangString::to_rust_string(&jvm, &utf).await?;
+    assert_eq!(string, "abcbd");
+
     Ok(())
 }
 

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

@@ -36,3 +36,28 @@ async fn test_data_output_stream() -> Result<()> {
 
     Ok(())
 }
+
+#[tokio::test]
+async fn test_data_output_stream_utf() -> Result<()> {
+    let jvm = test_jvm().await?;
+
+    let stream = jvm.new_class("java/io/ByteArrayOutputStream", "()V", ()).await?;
+    let data_output_stream = jvm
+        .new_class("java/io/DataOutputStream", "(Ljava/io/OutputStream;)V", (stream.clone(),))
+        .await?;
+
+    let string = JavaLangString::from_rust_string(&jvm, "hello, world").await?;
+    let _: () = jvm
+        .invoke_virtual(&data_output_stream, "writeUTF", "(Ljava/lang/String;)V", (string,))
+        .await?;
+
+    let bytes = jvm.invoke_virtual(&stream, "toByteArray", "()[B", ()).await?;
+
+    let length = jvm.array_length(&bytes).await?;
+    let mut buf = vec![0; length];
+    jvm.array_raw_buffer(&bytes).await?.read(0, &mut buf)?;
+
+    assert_eq!(buf, vec![0, 12, b'h', b'e', b'l', b'l', b'o', b',', b' ', b'w', b'o', b'r', b'l', b'd']);
+
+    Ok(())
+}