Match the JDK on regionMatches and drop leftover io copies

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

@@ -4,7 +4,7 @@ use alloc::{vec, vec::Vec};
 
 use java_class_proto::{JavaFieldProto, JavaMethodProto};
 use java_constants::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
-use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result};
+use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result, runtime::JavaLangString};
 
 use crate::{
     RuntimeClassProto, RuntimeContext,
@@ -336,11 +336,7 @@ impl BufferedReader {
                         return Ok(None.into());
                     }
 
-                    let line_length = line.len();
-                    let mut chars = jvm.instantiate_array("C", line_length).await?;
-                    jvm.store_array(&mut chars, 0, line).await?;
-                    let value = jvm.new_class("java/lang/String", "([CII)V", (chars, 0, line_length as i32)).await?;
-                    return Ok(value.into());
+                    return Ok(JavaLangString::from_utf16(jvm, line).await?.into());
                 }
                 next_char = jvm.get_field(&this, "nextChar", "I").await?;
                 n_chars = jvm.get_field(&this, "nChars", "I").await?;
@@ -367,11 +363,7 @@ impl BufferedReader {
                     jvm.put_field(&mut this, "skipLF", "Z", true).await?;
                 }
 
-                let line_length = line.len();
-                let mut chars = jvm.instantiate_array("C", line_length).await?;
-                jvm.store_array(&mut chars, 0, line).await?;
-                let value = jvm.new_class("java/lang/String", "([CII)V", (chars, 0, line_length as i32)).await?;
-                return Ok(value.into());
+                return Ok(JavaLangString::from_utf16(jvm, line).await?.into());
             }
 
             line.extend(buffered);

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

@@ -2,7 +2,7 @@ use alloc::{vec, vec::Vec};
 
 use java_class_proto::JavaMethodProto;
 use java_constants::MethodAccessFlags;
-use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result};
+use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result, runtime::JavaLangString};
 
 use crate::{
     RuntimeClassProto, RuntimeContext,
@@ -156,7 +156,7 @@ impl DataInputStream {
         tracing::debug!("java.io.DataInputStream::readUTF({this:?})");
 
         let length: i32 = jvm.invoke_virtual(&this, "readUnsignedShort", "()I", ()).await?;
-        let mut java_array = jvm.instantiate_array("B", length as usize).await?;
+        let java_array = jvm.instantiate_array("B", length as usize).await?;
         let _: () = jvm.invoke_virtual(&this, "readFully", "([BII)V", (java_array.clone(), 0, length)).await?;
         let bytes: Vec<i8> = jvm.load_array(&java_array, 0, length as usize).await?;
         let bytes: Vec<u8> = bytes.into_iter().map(|value| value as u8).collect();
@@ -192,9 +192,7 @@ impl DataInputStream {
             }
         }
 
-        java_array = jvm.instantiate_array("C", chars.len()).await?;
-        jvm.store_array(&mut java_array, 0, chars).await?;
-        Ok(jvm.new_class("java/lang/String", "([C)V", (java_array,)).await?.into())
+        Ok(JavaLangString::from_utf16(jvm, chars).await?.into())
     }
 
     async fn read_utf_from_input(jvm: &Jvm, _: &mut RuntimeContext, input: ClassInstanceRef<DataInput>) -> Result<ClassInstanceRef<String>> {

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

@@ -922,17 +922,20 @@ impl String {
             return Err(jvm.exception("java/lang/NullPointerException", "other is null").await);
         }
 
-        if toffset < 0 || ooffset < 0 || len < 0 {
+        if toffset < 0 || ooffset < 0 {
             return Ok(false);
         }
 
         let (this_value, this_offset, this_count) = Self::value_range(jvm, &this).await?;
         let (other_value, other_offset, other_count) = Self::value_range(jvm, &other).await?;
-        let end_t = toffset as usize + len as usize;
-        let end_o = ooffset as usize + len as usize;
-        if end_t > this_count || end_o > other_count {
+        // widened like the jdk does, so a len near i32::MAX fails the bounds test instead of overflowing
+        if toffset as i64 > this_count as i64 - len as i64 || ooffset as i64 > other_count as i64 - len as i64 {
             return Ok(false);
         }
+        // the jdk's comparison loop never runs for a non-positive len, so an in-range region trivially matches
+        if len <= 0 {
+            return Ok(true);
+        }
 
         let this_chars: Vec<JavaChar> = jvm.load_array(&this_value, this_offset + toffset as usize, len as usize).await?;
         let other_chars: Vec<JavaChar> = jvm.load_array(&other_value, other_offset + ooffset as usize, len as usize).await?;

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

@@ -1182,7 +1182,7 @@ async fn test_str_06_region_matches_without_ignore_case() -> Result<()> {
             .await?
     );
     assert!(
-        !jvm.invoke_virtual::<_, bool>(&source, "regionMatches", "(ILjava/lang/String;II)Z", (1, same, 1, -1))
+        jvm.invoke_virtual::<_, bool>(&source, "regionMatches", "(ILjava/lang/String;II)Z", (1, same, 1, -1))
             .await?
     );
 
@@ -1209,6 +1209,49 @@ async fn test_str_06_region_matches_without_ignore_case() -> Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn test_region_matches_non_positive_len() -> Result<()> {
+    let jvm = test_jvm().await?;
+    let source = JavaLangString::from_rust_string(&jvm, "Hello").await?;
+    let other = JavaLangString::from_rust_string(&jvm, "World").await?;
+
+    for len in [0, -1, i32::MIN] {
+        assert!(
+            jvm.invoke_virtual::<_, bool>(&source, "regionMatches", "(ILjava/lang/String;II)Z", (1, other.clone(), 2, len))
+                .await?
+        );
+        assert!(
+            jvm.invoke_virtual::<_, bool>(&source, "regionMatches", "(ZILjava/lang/String;II)Z", (true, 1, other.clone(), 2, len))
+                .await?
+        );
+    }
+
+    assert!(
+        jvm.invoke_virtual::<_, bool>(&source, "regionMatches", "(ILjava/lang/String;II)Z", (5, other.clone(), 5, 0))
+            .await?
+    );
+    assert!(
+        !jvm.invoke_virtual::<_, bool>(&source, "regionMatches", "(ILjava/lang/String;II)Z", (6, other.clone(), 0, 0))
+            .await?
+    );
+    assert!(
+        !jvm.invoke_virtual::<_, bool>(&source, "regionMatches", "(ILjava/lang/String;II)Z", (0, other.clone(), 0, i32::MAX))
+            .await?
+    );
+
+    let sub: ClassInstanceRef<JavaString> = jvm.invoke_virtual(&source, "substring", "(II)Ljava/lang/String;", (1, 3)).await?;
+    assert!(
+        jvm.invoke_virtual::<_, bool>(&sub, "regionMatches", "(ILjava/lang/String;II)Z", (2, other, 0, -1))
+            .await?
+    );
+    assert!(
+        !jvm.invoke_virtual::<_, bool>(&sub, "regionMatches", "(ILjava/lang/String;II)Z", (3, source, 0, 0))
+            .await?
+    );
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn test_str_07_locale_case_overloads_and_float_formatting() -> Result<()> {
     let jvm = test_jvm().await?;