[rustjava-upstream-sync-s2] merge upstream cut af4f6f8 (CLDC 1.1 core API, PR dlunch#177)

Conflicts (5, exactly as S1 predicted):
- java/io.rs, java/io/unsupported_encoding_exception.rs, loader.rs:
  upstream side is a superset; took it, then restored our
  ClassFormatError registration that --theirs had dropped from loader.rs.
- java/io/input_stream_reader.rs: kept our Charset abstraction (4 charsets
  vs upstream's inline 2) and adopted upstream's decode_length/end_of_input
  multibyte-boundary handling on top of it.
- tests/.../test_input_stream_reader.rs: union of both sides' tests.

Also fixed a silent auto-merge duplicate: both sides added a byte-identical
Throwable::getMessage at different positions, so git merged both and the
build failed with E0592. Kept upstream's placement.

InputStreamReader's single-argument ctor stays lazy about the default
charset (JDK does not declare it to throw UnsupportedEncodingException);
only the (InputStream, String) ctor validates eagerly, as upstream added.

cargo fmt/clippy/clippy-wasm32/test all rc=0; 191 passed / 0 failed.

Author: jun0

java_runtime/src/charset.rs

@@ -25,6 +25,16 @@ impl Charset {
         }
     }
 
+    // Canonical name stored in InputStreamReader's charset field and compared there.
+    pub fn canonical_name(&self) -> &'static str {
+        match self {
+            Self::Utf8 => "UTF-8",
+            Self::EucKr => "EUC-KR",
+            Self::Iso8859_1 => "ISO-8859-1",
+            Self::UsAscii => "US-ASCII",
+        }
+    }
+
     pub async fn resolve(jvm: &Jvm, name: &str) -> Result<Self> {
         match Self::from_name(name) {
             Some(x) => Ok(x),

java_runtime/src/classes/java/io.rs

@@ -15,23 +15,28 @@ mod filter_input_stream;
 mod filter_output_stream;
 mod input_stream;
 mod input_stream_reader;
+mod interrupted_io_exception;
 mod io_exception;
 mod output_stream;
+mod output_stream_writer;
 mod print_stream;
 mod print_writer;
 mod random_access_file;
 mod reader;
 mod serializable;
 mod string_writer;
 mod unsupported_encoding_exception;
+mod utf_data_format_exception;
 mod writer;
 
 pub use self::{
     buffered_reader::BufferedReader, byte_array_input_stream::ByteArrayInputStream, byte_array_output_stream::ByteArrayOutputStream,
     data_input::DataInput, data_input_stream::DataInputStream, data_output::DataOutput, data_output_stream::DataOutputStream,
     eof_exception::EOFException, file::File, file_descriptor::FileDescriptor, file_input_stream::FileInputStream,
     file_not_found_exception::FileNotFoundException, file_output_stream::FileOutputStream, filter_input_stream::FilterInputStream,
-    filter_output_stream::FilterOutputStream, input_stream::InputStream, input_stream_reader::InputStreamReader, io_exception::IOException,
-    output_stream::OutputStream, print_stream::PrintStream, print_writer::PrintWriter, random_access_file::RandomAccessFile, reader::Reader,
-    serializable::Serializable, string_writer::StringWriter, unsupported_encoding_exception::UnsupportedEncodingException, writer::Writer,
+    filter_output_stream::FilterOutputStream, input_stream::InputStream, input_stream_reader::InputStreamReader,
+    interrupted_io_exception::InterruptedIOException, io_exception::IOException, output_stream::OutputStream,
+    output_stream_writer::OutputStreamWriter, print_stream::PrintStream, print_writer::PrintWriter, random_access_file::RandomAccessFile,
+    reader::Reader, serializable::Serializable, string_writer::StringWriter, unsupported_encoding_exception::UnsupportedEncodingException,
+    utf_data_format_exception::UTFDataFormatException, writer::Writer,
 };

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

@@ -24,6 +24,7 @@ impl ByteArrayInputStream {
                 JavaMethodProto::new("skip", "(J)J", Self::skip, Default::default()),
                 JavaMethodProto::new("mark", "(I)V", Self::mark, Default::default()),
                 JavaMethodProto::new("reset", "()V", Self::reset, Default::default()),
+                JavaMethodProto::new("markSupported", "()Z", Self::mark_supported, Default::default()),
             ],
             fields: vec![
                 JavaFieldProto::new("buf", "[B", Default::default()),
@@ -57,11 +58,17 @@ impl ByteArrayInputStream {
     ) -> Result<()> {
         tracing::debug!("java.io.ByteArrayInputStream::<init>({this:?}, {data:?}, {offset}, {length})");
 
+        let data_length = jvm.array_length(&data).await? as i32;
+        if offset < 0 || length < 0 || offset > data_length {
+            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
+        }
+
         let _: () = jvm.invoke_special(&this, "java/io/InputStream", "<init>", "()V", ()).await?;
 
         jvm.put_field(&mut this, "buf", "[B", data).await?;
         jvm.put_field(&mut this, "pos", "I", offset).await?;
-        jvm.put_field(&mut this, "count", "I", length).await?;
+        jvm.put_field(&mut this, "count", "I", (offset + length).min(data_length)).await?;
+        jvm.put_field(&mut this, "mark", "I", offset).await?;
 
         Ok(())
     }
@@ -85,15 +92,23 @@ impl ByteArrayInputStream {
     ) -> Result<i32> {
         tracing::debug!("java.io.ByteArrayInputStream::read({this:?}, {b:?}, {off}, {len})");
 
-        let buf = jvm.get_field(&this, "buf", "[B").await?;
-        let buf_length = jvm.array_length(&buf).await?;
+        let buf: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "buf", "[B").await?;
+        let count: i32 = jvm.get_field(&this, "count", "I").await?;
         let pos: i32 = jvm.get_field(&this, "pos", "I").await?;
 
-        let available = (buf_length as i32 - pos) as _;
-        let len_to_read = if len > available { available } else { len };
-        if len_to_read == 0 {
+        let target_length = jvm.array_length(&b).await? as i32;
+        if off < 0 || len < 0 || off > target_length - len {
+            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
+        }
+        if len == 0 {
+            return Ok(0);
+        }
+
+        let available = count - pos;
+        if available <= 0 {
             return Ok(-1);
         }
+        let len_to_read = if len > available { available } else { len };
 
         let _: () = jvm
             .invoke_static(
@@ -113,10 +128,10 @@ impl ByteArrayInputStream {
         tracing::debug!("java.io.ByteArrayInputStream::readByte({this:?})");
 
         let buf = jvm.get_field(&this, "buf", "[B").await?;
-        let buf_length = jvm.array_length(&buf).await?;
+        let count: i32 = jvm.get_field(&this, "count", "I").await?;
         let pos: i32 = jvm.get_field(&this, "pos", "I").await?;
 
-        if pos as usize >= buf_length {
+        if pos >= count {
             return Ok(-1);
         }
 
@@ -136,12 +151,11 @@ impl ByteArrayInputStream {
     async fn skip(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, n: i64) -> Result<i64> {
         tracing::debug!("java.io.ByteArrayInputStream::skip({this:?}, {n:?})");
 
-        let buf = jvm.get_field(&this, "buf", "[B").await?;
-        let buf_length = jvm.array_length(&buf).await?;
+        let count: i32 = jvm.get_field(&this, "count", "I").await?;
         let pos: i32 = jvm.get_field(&this, "pos", "I").await?;
 
-        let available = (buf_length as i32 - pos) as i64;
-        let len_to_skip = if n > available { available } else { n };
+        let available = (count - pos) as i64;
+        let len_to_skip = n.max(0).min(available);
 
         jvm.put_field(&mut this, "pos", "I", pos + len_to_skip as i32).await?;
 
@@ -165,4 +179,9 @@ impl ByteArrayInputStream {
 
         Ok(())
     }
+
+    async fn mark_supported(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
+        tracing::debug!("java.io.ByteArrayInputStream::markSupported({this:?})");
+        Ok(true)
+    }
 }

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

@@ -1,9 +1,9 @@
-use alloc::vec;
+use alloc::{vec, vec::Vec};
 
 use java_class_proto::{JavaFieldProto, JavaMethodProto};
 use jvm::{Array, ClassInstanceRef, Jvm, Result};
 
-use crate::{RuntimeClassProto, RuntimeContext};
+use crate::{RuntimeClassProto, RuntimeContext, classes::java::lang::String};
 
 // class java.io.ByteArrayOutputStream
 pub struct ByteArrayOutputStream;
@@ -18,7 +18,9 @@ impl ByteArrayOutputStream {
                 JavaMethodProto::new("<init>", "()V", Self::init, Default::default()),
                 JavaMethodProto::new("<init>", "(I)V", Self::init_with_size, Default::default()),
                 JavaMethodProto::new("write", "(I)V", Self::write, Default::default()),
+                JavaMethodProto::new("write", "([BII)V", Self::write_bytes, Default::default()),
                 JavaMethodProto::new("toByteArray", "()[B", Self::to_byte_array, Default::default()),
+                JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, Default::default()),
                 JavaMethodProto::new("size", "()I", Self::size, Default::default()),
                 JavaMethodProto::new("reset", "()V", Self::reset, Default::default()),
                 JavaMethodProto::new("close", "()V", Self::close, Default::default()),
@@ -44,16 +46,43 @@ impl ByteArrayOutputStream {
     async fn init_with_size(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, size: i32) -> Result<()> {
         tracing::debug!("java.io.ByteArrayOutputStream::<init>({this:?}, {size:?})");
 
+        if size < 0 {
+            return Err(jvm.exception("java/lang/IllegalArgumentException", "Negative initial size").await);
+        }
+
         let _: () = jvm.invoke_special(&this, "java/io/OutputStream", "<init>", "()V", ()).await?;
 
-        let array = jvm.instantiate_array("B", 1024).await?;
+        let array = jvm.instantiate_array("B", size as usize).await?;
 
         jvm.put_field(&mut this, "buf", "[B", array).await?;
         jvm.put_field(&mut this, "pos", "I", 0).await?;
 
         Ok(())
     }
 
+    async fn write_bytes(
+        jvm: &Jvm,
+        _: &mut RuntimeContext,
+        mut this: ClassInstanceRef<Self>,
+        bytes: ClassInstanceRef<Array<i8>>,
+        off: i32,
+        len: i32,
+    ) -> Result<()> {
+        tracing::debug!("java.io.ByteArrayOutputStream::write({this:?}, {bytes:?}, {off}, {len})");
+
+        let length = jvm.array_length(&bytes).await? as i32;
+        if off < 0 || len < 0 || off > length - len {
+            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
+        }
+
+        let pos: i32 = jvm.get_field(&this, "pos", "I").await?;
+        Self::ensure_capacity(jvm, &mut this, (pos + len) as usize).await?;
+        let mut buf = jvm.get_field(&this, "buf", "[B").await?;
+        let values: Vec<i8> = jvm.load_array(&bytes, off as usize, len as usize).await?;
+        jvm.store_array(&mut buf, pos as usize, values).await?;
+        jvm.put_field(&mut this, "pos", "I", pos + len).await
+    }
+
     async fn write(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, b: i32) -> Result<()> {
         tracing::debug!("java.io.ByteArrayOutputStream::write({this:?}, {b:?})");
 
@@ -95,6 +124,22 @@ impl ByteArrayOutputStream {
         Ok(pos)
     }
 
+    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
+        tracing::debug!("java.io.ByteArrayOutputStream::toString({this:?})");
+        let buf: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "buf", "[B").await?;
+        let pos: i32 = jvm.get_field(&this, "pos", "I").await?;
+        let bytes = jvm.instantiate_array("B", pos as usize).await?;
+        let _: () = jvm
+            .invoke_static(
+                "java/lang/System",
+                "arraycopy",
+                "(Ljava/lang/Object;ILjava/lang/Object;II)V",
+                (buf, 0, bytes.clone(), 0, pos),
+            )
+            .await?;
+        Ok(jvm.new_class("java/lang/String", "([B)V", (bytes,)).await?.into())
+    }
+
     async fn reset(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
         tracing::debug!("java.io.ByteArrayOutputStream::reset({this:?})");
 

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

@@ -24,6 +24,7 @@ impl DataInput {
                 JavaMethodProto::new_abstract("readInt", "()I", Default::default()),
                 JavaMethodProto::new_abstract("readLong", "()J", Default::default()),
                 JavaMethodProto::new_abstract("readShort", "()S", Default::default()),
+                JavaMethodProto::new_abstract("readUnsignedByte", "()I", Default::default()),
                 JavaMethodProto::new_abstract("readUnsignedShort", "()I", Default::default()),
                 JavaMethodProto::new_abstract("readUTF", "()Ljava/lang/String;", Default::default()),
                 JavaMethodProto::new_abstract("skipBytes", "(I)I", Default::default()),