Fix CI lint and improve CLDC coverage

Author: dlunch

java_runtime/src/classes/java/util/random.rs

@@ -75,7 +75,7 @@ impl Random {
             return Err(jvm.exception("java/lang/IllegalArgumentException", "n must be positive").await);
         }
 
-        if bound & -bound == bound {
+        if (bound as u32).is_power_of_two() {
             let bits: i32 = jvm.invoke_virtual(&this, "next", "(I)I", (31,)).await?;
             return Ok(((bound as i64 * bits as i64) >> 31) as i32);
         }

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

@@ -1,4 +1,4 @@
-use jvm::Result;
+use jvm::{JavaError, Result};
 
 use test_utils::test_jvm;
 
@@ -26,3 +26,76 @@ async fn test_mark_reset() -> Result<()> {
 
     Ok(())
 }
+
+#[tokio::test]
+async fn test_input_stream_default_contract() -> Result<()> {
+    let jvm = test_jvm().await?;
+
+    let mut data = jvm.instantiate_array("B", 3).await?;
+    jvm.store_array(&mut data, 0, [10i8, 20, 30]).await?;
+    let stream = jvm.new_class("java/io/ByteArrayInputStream", "([B)V", (data,)).await?;
+    let target = jvm.instantiate_array("B", 5).await?;
+
+    assert_eq!(
+        jvm.invoke_special::<_, i32>(&stream, "java/io/InputStream", "read", "([BII)I", (target.clone(), 1, 3))
+            .await?,
+        3
+    );
+    assert_eq!(jvm.load_array::<i8>(&target, 0, 5).await?, [0, 10, 20, 30, 0]);
+    assert_eq!(
+        jvm.invoke_special::<_, i32>(&stream, "java/io/InputStream", "read", "([BII)I", (target.clone(), 0, 1))
+            .await?,
+        -1
+    );
+    assert_eq!(
+        jvm.invoke_special::<_, i32>(&stream, "java/io/InputStream", "read", "([BII)I", (target.clone(), 0, 0))
+            .await?,
+        0
+    );
+
+    let invalid: Result<i32> = jvm
+        .invoke_special(&stream, "java/io/InputStream", "read", "([BII)I", (target, -1, 1))
+        .await;
+    let Err(JavaError::JavaException(exception)) = invalid else {
+        panic!("invalid range must throw IndexOutOfBoundsException");
+    };
+    assert!(jvm.is_instance(&*exception, "java/lang/IndexOutOfBoundsException"));
+
+    let mut data = jvm.instantiate_array("B", 3).await?;
+    jvm.store_array(&mut data, 0, [1i8, 2, 3]).await?;
+    let stream = jvm.new_class("java/io/ByteArrayInputStream", "([B)V", (data,)).await?;
+    assert_eq!(
+        jvm.invoke_special::<_, i64>(&stream, "java/io/InputStream", "skip", "(J)J", (2i64,))
+            .await?,
+        2
+    );
+    assert_eq!(
+        jvm.invoke_special::<_, i64>(&stream, "java/io/InputStream", "skip", "(J)J", (5i64,))
+            .await?,
+        1
+    );
+    assert_eq!(
+        jvm.invoke_special::<_, i64>(&stream, "java/io/InputStream", "skip", "(J)J", (-1i64,))
+            .await?,
+        0
+    );
+    assert_eq!(
+        jvm.invoke_special::<_, i32>(&stream, "java/io/InputStream", "available", "()I", ())
+            .await?,
+        0
+    );
+    assert!(
+        !jvm.invoke_special::<_, bool>(&stream, "java/io/InputStream", "markSupported", "()Z", ())
+            .await?
+    );
+    let _: () = jvm.invoke_special(&stream, "java/io/InputStream", "mark", "(I)V", (10,)).await?;
+
+    let reset: Result<()> = jvm.invoke_special(&stream, "java/io/InputStream", "reset", "()V", ()).await;
+    let Err(JavaError::JavaException(exception)) = reset else {
+        panic!("default reset must throw IOException");
+    };
+    assert!(jvm.is_instance(&*exception, "java/io/IOException"));
+    let _: () = jvm.invoke_special(&stream, "java/io/InputStream", "close", "()V", ()).await?;
+
+    Ok(())
+}

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

@@ -1,6 +1,7 @@
 use alloc::{vec, vec::Vec};
 
-use jvm::{JavaChar, JavaError, Result, runtime::JavaLangString};
+use java_runtime::classes::java::lang::Object;
+use jvm::{ClassInstanceRef, JavaChar, JavaError, Result, runtime::JavaLangString};
 
 use test_utils::test_jvm;
 
@@ -76,3 +77,64 @@ async fn test_input_stream_reader_rejects_unknown_encoding() -> Result<()> {
 
     Ok(())
 }
+
+#[tokio::test]
+async fn test_reader_default_contract_and_lifecycle() -> Result<()> {
+    let jvm = test_jvm().await?;
+
+    let mut bytes = jvm.instantiate_array("B", 3).await?;
+    jvm.store_array(&mut bytes, 0, [b'a' as i8, b'b' as i8, b'c' as i8]).await?;
+    let input = jvm.new_class("java/io/ByteArrayInputStream", "([B)V", (bytes,)).await?;
+    let reader = jvm.new_class("java/io/InputStreamReader", "(Ljava/io/InputStream;)V", (input,)).await?;
+
+    assert!(jvm.invoke_virtual::<_, bool>(&reader, "ready", "()Z", ()).await?);
+    assert!(!jvm.invoke_special::<_, bool>(&reader, "java/io/Reader", "ready", "()Z", ()).await?);
+    assert_eq!(jvm.invoke_virtual::<_, i32>(&reader, "read", "()I", ()).await?, 'a' as i32);
+
+    let chars = jvm.instantiate_array("C", 2).await?;
+    assert_eq!(jvm.invoke_virtual::<_, i32>(&reader, "read", "([C)I", (chars.clone(),)).await?, 2);
+    assert_eq!(jvm.load_array::<JavaChar>(&chars, 0, 2).await?, ['b' as JavaChar, 'c' as JavaChar]);
+    assert_eq!(jvm.invoke_virtual::<_, i32>(&reader, "read", "()I", ()).await?, -1);
+
+    let empty = jvm.instantiate_array("C", 0).await?;
+    assert_eq!(jvm.invoke_virtual::<_, i32>(&reader, "read", "([CII)I", (empty, 0, 0)).await?, 0);
+    assert!(!jvm.invoke_virtual::<_, bool>(&reader, "markSupported", "()Z", ()).await?);
+
+    let mark: Result<()> = jvm.invoke_virtual(&reader, "mark", "(I)V", (1,)).await;
+    let Err(JavaError::JavaException(exception)) = mark else {
+        panic!("default mark must throw IOException");
+    };
+    assert!(jvm.is_instance(&*exception, "java/io/IOException"));
+
+    let reset: Result<()> = jvm.invoke_virtual(&reader, "reset", "()V", ()).await;
+    let Err(JavaError::JavaException(exception)) = reset else {
+        panic!("default reset must throw IOException");
+    };
+    assert!(jvm.is_instance(&*exception, "java/io/IOException"));
+
+    let negative_skip: Result<i64> = jvm.invoke_virtual(&reader, "skip", "(J)J", (-1i64,)).await;
+    let Err(JavaError::JavaException(exception)) = negative_skip else {
+        panic!("negative skip must throw IllegalArgumentException");
+    };
+    assert!(jvm.is_instance(&*exception, "java/lang/IllegalArgumentException"));
+
+    let mut bytes = jvm.instantiate_array("B", 3).await?;
+    jvm.store_array(&mut bytes, 0, [b'x' as i8, b'y' as i8, b'z' as i8]).await?;
+    let input = jvm.new_class("java/io/ByteArrayInputStream", "([B)V", (bytes,)).await?;
+    let reader = jvm.new_class("java/io/InputStreamReader", "(Ljava/io/InputStream;)V", (input,)).await?;
+    assert_eq!(jvm.invoke_virtual::<_, i64>(&reader, "skip", "(J)J", (2i64,)).await?, 2);
+    assert_eq!(jvm.invoke_virtual::<_, i32>(&reader, "read", "()I", ()).await?, 'z' as i32);
+    assert_eq!(jvm.invoke_virtual::<_, i64>(&reader, "skip", "(J)J", (2i64,)).await?, 0);
+    let _: () = jvm.invoke_virtual(&reader, "close", "()V", ()).await?;
+
+    let null_lock: ClassInstanceRef<Object> = None.into();
+    let result: Result<()> = jvm
+        .invoke_special(&reader, "java/io/Reader", "<init>", "(Ljava/lang/Object;)V", (null_lock,))
+        .await;
+    let Err(JavaError::JavaException(exception)) = result else {
+        panic!("null lock must throw NullPointerException");
+    };
+    assert!(jvm.is_instance(&*exception, "java/lang/NullPointerException"));
+
+    Ok(())
+}

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

@@ -1,6 +1,10 @@
 use alloc::vec::Vec;
 
-use jvm::{Array, ClassInstanceRef, JavaChar, Result, runtime::JavaLangString};
+use java_runtime::classes::java::{
+    io::OutputStream,
+    lang::{Object, String},
+};
+use jvm::{Array, ClassInstanceRef, JavaChar, JavaError, Result, runtime::JavaLangString};
 
 use test_utils::test_jvm;
 
@@ -36,3 +40,57 @@ async fn test_print_stream_cldc_api() -> Result<()> {
 
     Ok(())
 }
+
+#[tokio::test]
+async fn test_print_stream_remaining_overloads_and_close() -> Result<()> {
+    let jvm = test_jvm().await?;
+
+    let output = jvm.new_class("java/io/ByteArrayOutputStream", "()V", ()).await?;
+    let stream = jvm
+        .new_class("java/io/PrintStream", "(Ljava/io/OutputStream;)V", (output.clone(),))
+        .await?;
+    let text = JavaLangString::from_rust_string(&jvm, "obj").await?;
+    let object: ClassInstanceRef<Object> = text.clone().into();
+    let null_object: ClassInstanceRef<Object> = None.into();
+    let null_string: ClassInstanceRef<String> = None.into();
+
+    let _: () = jvm.invoke_virtual(&stream, "print", "(Ljava/lang/Object;)V", (object.clone(),)).await?;
+    let _: () = jvm.invoke_virtual(&stream, "print", "(Ljava/lang/Object;)V", (null_object,)).await?;
+    let _: () = jvm
+        .invoke_virtual(&stream, "print", "(Ljava/lang/String;)V", (null_string.clone(),))
+        .await?;
+    let _: () = jvm.invoke_virtual(&stream, "print", "(J)V", (9i64,)).await?;
+    let _: () = jvm.invoke_virtual(&stream, "write", "(I)V", ('|' as i32,)).await?;
+
+    let _: () = jvm.invoke_virtual(&stream, "println", "(Ljava/lang/Object;)V", (object,)).await?;
+    let _: () = jvm.invoke_virtual(&stream, "println", "(Ljava/lang/String;)V", (null_string,)).await?;
+    let _: () = jvm.invoke_virtual(&stream, "println", "(I)V", (-1,)).await?;
+    let _: () = jvm.invoke_virtual(&stream, "println", "(J)V", (2i64,)).await?;
+    let _: () = jvm.invoke_virtual(&stream, "println", "(C)V", ('A' as JavaChar,)).await?;
+
+    let mut chars = jvm.instantiate_array("C", 2).await?;
+    jvm.store_array(&mut chars, 0, ['B' as JavaChar, 'C' as JavaChar]).await?;
+    let _: () = jvm.invoke_virtual(&stream, "println", "([C)V", (chars,)).await?;
+    let _: () = jvm.invoke_virtual(&stream, "println", "(B)V", (-3i8,)).await?;
+    let _: () = jvm.invoke_virtual(&stream, "println", "(S)V", (4i16,)).await?;
+    let _: () = jvm.invoke_virtual(&stream, "println", "(Z)V", (false,)).await?;
+    let _: () = jvm.invoke_virtual(&stream, "println", "(F)V", (2.5f32,)).await?;
+    let _: () = jvm.invoke_virtual(&stream, "close", "()V", ()).await?;
+    assert!(!jvm.invoke_virtual::<_, bool>(&stream, "checkError", "()Z", ()).await?);
+
+    let bytes: ClassInstanceRef<Array<i8>> = jvm.invoke_virtual(&output, "toByteArray", "()[B", ()).await?;
+    let values: Vec<i8> = jvm.load_array(&bytes, 0, jvm.array_length(&bytes).await?).await?;
+    assert_eq!(
+        values.into_iter().map(|value| value as u8).collect::<Vec<_>>(),
+        b"objnullnull9|obj\nnull\n-1\n2\nA\nBC\n-3\n4\nfalse\n2.5\n"
+    );
+
+    let null_output: ClassInstanceRef<OutputStream> = None.into();
+    let result = jvm.new_class("java/io/PrintStream", "(Ljava/io/OutputStream;)V", (null_output,)).await;
+    let Err(JavaError::JavaException(exception)) = result else {
+        panic!("null output must throw NullPointerException");
+    };
+    assert!(jvm.is_instance(&*exception, "java/lang/NullPointerException"));
+
+    Ok(())
+}

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

@@ -1,6 +1,7 @@
 use alloc::vec;
 
-use jvm::{JavaChar, Result, runtime::JavaLangString};
+use java_runtime::classes::java::lang::Object;
+use jvm::{ClassInstanceRef, JavaChar, JavaError, Result, runtime::JavaLangString};
 
 use test_utils::test_jvm;
 
@@ -17,14 +18,34 @@ async fn test_string_writer() -> Result<()> {
 
     let _: () = jvm.invoke_virtual(&string_writer, "write", "([CII)V", (buf.clone(), 0, 3)).await?;
 
-    let _: () = jvm.invoke_virtual(&string_writer, "write", "([CII)V", (buf, 1, 2)).await?;
+    let _: () = jvm.invoke_virtual(&string_writer, "write", "([CII)V", (buf.clone(), 1, 2)).await?;
     let _: () = jvm.invoke_virtual(&string_writer, "write", "(I)V", ('d' as i32,)).await?;
+    let _: () = jvm.invoke_virtual(&string_writer, "write", "([C)V", (buf,)).await?;
+
+    let value = JavaLangString::from_rust_string(&jvm, "XYZ").await?;
+    let _: () = jvm
+        .invoke_virtual(&string_writer, "write", "(Ljava/lang/String;)V", (value.clone(),))
+        .await?;
+    let _: () = jvm
+        .invoke_virtual(&string_writer, "write", "(Ljava/lang/String;II)V", (value, 1, 1))
+        .await?;
+    let _: () = jvm.invoke_virtual(&string_writer, "flush", "()V", ()).await?;
+    let _: () = jvm.invoke_virtual(&string_writer, "close", "()V", ()).await?;
 
     let string = jvm.invoke_virtual(&string_writer, "toString", "()Ljava/lang/String;", ()).await.unwrap();
 
     let string = JavaLangString::to_rust_string(&jvm, &string).await?;
 
-    assert_eq!(string, "abcbcd"); // cspell: disable-line
+    assert_eq!(string, "abcbcdabcXYZY"); // cspell: disable-line
+
+    let null_lock: ClassInstanceRef<Object> = None.into();
+    let result: Result<()> = jvm
+        .invoke_special(&string_writer, "java/io/Writer", "<init>", "(Ljava/lang/Object;)V", (null_lock,))
+        .await;
+    let Err(JavaError::JavaException(exception)) = result else {
+        panic!("null lock must throw NullPointerException");
+    };
+    assert!(jvm.is_instance(&*exception, "java/lang/NullPointerException"));
 
     Ok(())
 }

java_runtime/tests/classes/java/util/test_timezone.rs

@@ -1,5 +1,5 @@
-use java_runtime::classes::java::util::TimeZone;
-use jvm::{Array, ClassInstanceRef, Result, runtime::JavaLangString};
+use java_runtime::classes::java::{lang::String, util::TimeZone};
+use jvm::{Array, ClassInstanceRef, JavaError, Result, runtime::JavaLangString};
 
 use test_utils::test_jvm;
 
@@ -51,3 +51,39 @@ async fn test_timezone() -> Result<()> {
 
     Ok(())
 }
+
+#[tokio::test]
+async fn test_simple_timezone_constructors_and_offset_validation() -> Result<()> {
+    let jvm = test_jvm().await?;
+
+    let id = JavaLangString::from_rust_string(&jvm, "Fixed").await?;
+    let timezone = jvm
+        .new_class("java/util/SimpleTimeZone", "(ILjava/lang/String;)V", (3_600_000, id))
+        .await?;
+    assert_eq!(jvm.invoke_virtual::<_, i32>(&timezone, "getRawOffset", "()I", ()).await?, 3_600_000);
+    assert_eq!(
+        jvm.invoke_virtual::<_, i32>(&timezone, "getOffset", "(IIIIII)I", (1, 2026, 0, 1, 1, 0))
+            .await?,
+        3_600_000
+    );
+
+    let invalid: Result<i32> = jvm.invoke_virtual(&timezone, "getOffset", "(IIIIII)I", (2, 2026, 0, 1, 1, 0)).await;
+    let Err(JavaError::JavaException(exception)) = invalid else {
+        panic!("invalid era must throw IllegalArgumentException");
+    };
+    assert!(jvm.is_instance(&*exception, "java/lang/IllegalArgumentException"));
+
+    let id = JavaLangString::from_rust_string(&jvm, "Legacy").await?;
+    let legacy = jvm.new_class("java/util/SimpleTimeZone", "(Ljava/lang/String;)V", (id,)).await?;
+    assert_eq!(jvm.invoke_virtual::<_, i32>(&legacy, "getRawOffset", "()I", ()).await?, 0);
+    assert!(!jvm.invoke_virtual::<_, bool>(&legacy, "useDaylightTime", "()Z", ()).await?);
+
+    let null_id: ClassInstanceRef<String> = None.into();
+    let result = jvm.new_class("java/util/SimpleTimeZone", "(ILjava/lang/String;)V", (0, null_id)).await;
+    let Err(JavaError::JavaException(exception)) = result else {
+        panic!("null ID must throw NullPointerException");
+    };
+    assert!(jvm.is_instance(&*exception, "java/lang/NullPointerException"));
+
+    Ok(())
+}