Replace runtime panics with the matching Java exceptions

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

@@ -59,12 +59,7 @@ impl File {
         let path = jvm.invoke_virtual(&this, "getPath", "()Ljava/lang/String;", ()).await?;
         let path = JavaLangString::to_rust_string(jvm, &path).await?;
 
-        let stat = context.metadata(&path).await;
-        if stat.is_err() {
-            return Ok(false);
-        }
-
-        Ok(stat.unwrap().r#type == FileType::Directory)
+        Ok(context.metadata(&path).await.is_ok_and(|x| x.r#type == FileType::Directory))
     }
 
     async fn is_file(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
@@ -73,12 +68,7 @@ impl File {
         let path = jvm.invoke_virtual(&this, "getPath", "()Ljava/lang/String;", ()).await?;
         let path = JavaLangString::to_rust_string(jvm, &path).await?;
 
-        let stat = context.metadata(&path).await;
-        if stat.is_err() {
-            return Ok(false);
-        }
-
-        Ok(stat.unwrap().r#type == FileType::File)
+        Ok(context.metadata(&path).await.is_ok_and(|x| x.r#type == FileType::File))
     }
 
     async fn delete(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
@@ -96,8 +86,7 @@ impl File {
         let path = jvm.invoke_virtual(&this, "getPath", "()Ljava/lang/String;", ()).await?;
         let path = JavaLangString::to_rust_string(jvm, &path).await?;
 
-        let stat = context.metadata(&path).await.unwrap();
-
-        Ok(stat.size as _)
+        // File.length() is 0 when the file does not exist
+        Ok(context.metadata(&path).await.map_or(0, |x| x.size as _))
     }
 }

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

@@ -79,8 +79,12 @@ impl FileInputStream {
         let rust_file = FileDescriptor::file(jvm, context, fd).await?;
 
         // TODO get os buffer size
-        let stat = rust_file.metadata().await.unwrap();
-        let tell = rust_file.tell().await.unwrap();
+        let Ok(stat) = rust_file.metadata().await else {
+            return Err(jvm.exception("java/io/IOException", "I/O error").await);
+        };
+        let Ok(tell) = rust_file.tell().await else {
+            return Err(jvm.exception("java/io/IOException", "I/O error").await);
+        };
 
         let available = stat.size - tell;
 
@@ -101,7 +105,9 @@ impl FileInputStream {
         let mut rust_file = FileDescriptor::file(jvm, context, fd).await?;
 
         let mut rust_buf = vec![0; length as _];
-        let read = rust_file.read(&mut rust_buf).await.unwrap();
+        let Ok(read) = rust_file.read(&mut rust_buf).await else {
+            return Err(jvm.exception("java/io/IOException", "I/O error").await);
+        };
         if read == 0 {
             return Ok(-1);
         }
@@ -118,7 +124,9 @@ impl FileInputStream {
         let mut rust_file = FileDescriptor::file(jvm, context, fd).await?;
 
         let mut buf = [0; 1];
-        let read = rust_file.read(&mut buf).await.unwrap();
+        let Ok(read) = rust_file.read(&mut buf).await else {
+            return Err(jvm.exception("java/io/IOException", "I/O error").await);
+        };
         if read == 0 {
             return Ok(-1);
         }

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

@@ -42,8 +42,12 @@ impl FileOutputStream {
         let path = jvm.invoke_virtual(&file, "getPath", "()Ljava/lang/String;", ()).await?;
         let path = JavaLangString::to_rust_string(jvm, &path).await?;
 
-        let fd = context.open(&path, true).await.unwrap();
-        let fd = FileDescriptor::from_fd(jvm, fd).await?;
+        let fd = context.open(&path, true).await;
+        if fd.is_err() {
+            return Err(jvm.exception("java/io/FileNotFoundException", "File not found").await);
+        }
+
+        let fd = FileDescriptor::from_fd(jvm, fd.unwrap()).await?;
 
         let _: () = jvm
             .invoke_special(&this, "java/io/FileOutputStream", "<init>", "(Ljava/io/FileDescriptor;)V", (fd,))
@@ -81,9 +85,11 @@ impl FileOutputStream {
         let mut file = FileDescriptor::file(jvm, context, fd).await?;
 
         let mut buf = vec![0; length as _];
-        jvm.array_raw_buffer(&buffer).await?.read(offset as _, &mut buf).unwrap();
+        jvm.array_raw_buffer(&buffer).await?.read(offset as _, &mut buf)?;
 
-        file.write(cast_slice(&buf)).await.unwrap();
+        if file.write(cast_slice(&buf)).await.is_err() {
+            return Err(jvm.exception("java/io/IOException", "I/O error").await);
+        }
 
         Ok(())
     }
@@ -94,7 +100,9 @@ impl FileOutputStream {
         let fd = jvm.get_field(&this, "fd", "Ljava/io/FileDescriptor;").await?;
         let mut file = FileDescriptor::file(jvm, context, fd).await?;
 
-        file.write(&[byte as u8]).await.unwrap();
+        if file.write(&[byte as u8]).await.is_err() {
+            return Err(jvm.exception("java/io/IOException", "I/O error").await);
+        }
 
         Ok(())
     }

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

@@ -103,7 +103,7 @@ impl InputStreamReader {
 
             let read_buf_size: i32 = jvm.get_field(&this, "readBufSize", "I").await?;
             let mut read_buf_data = vec![0; read_buf_size as _];
-            jvm.array_raw_buffer(&read_buf).await?.read(0, &mut read_buf_data).unwrap();
+            jvm.array_raw_buffer(&read_buf).await?.read(0, &mut read_buf_data)?;
 
             let charset_ref = jvm.get_field(&this, "charset", "Ljava/lang/String;").await?;
             let charset = JavaLangString::to_rust_string(jvm, &charset_ref).await?;

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

@@ -110,7 +110,8 @@ impl PrintStream {
     async fn println_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, char: JavaChar) -> Result<()> {
         tracing::debug!("java.io.PrintStream::println({this:?}, {char:?})");
 
-        let char = char::from_u32(char as _).unwrap();
+        // an unpaired surrogate is not a valid char; the JDK charset encoder replaces it with '?'
+        let char = char::from_u32(char as _).unwrap_or('?');
 
         let java_string = JavaLangString::from_rust_string(jvm, &char.to_string()).await?;
 

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

@@ -114,7 +114,9 @@ impl RandomAccessFile {
         let mut rust_file = FileDescriptor::file(jvm, context, fd).await?;
 
         let mut rust_buf = vec![0; length as usize];
-        let read = rust_file.read(&mut rust_buf).await.unwrap();
+        let Ok(read) = rust_file.read(&mut rust_buf).await else {
+            return Err(jvm.exception("java/io/IOException", "I/O error").await);
+        };
 
         jvm.array_raw_buffer_mut(&mut buf).await?.write(offset as _, &rust_buf)?;
 
@@ -144,8 +146,10 @@ impl RandomAccessFile {
         let mut rust_file = FileDescriptor::file(jvm, context, fd).await?;
 
         let mut rust_buf = vec![0; length as usize];
-        jvm.array_raw_buffer(&buf).await?.read(offset as _, &mut rust_buf).unwrap();
-        rust_file.write(&cast_vec(rust_buf)).await.unwrap();
+        jvm.array_raw_buffer(&buf).await?.read(offset as _, &mut rust_buf)?;
+        if rust_file.write(&cast_vec(rust_buf)).await.is_err() {
+            return Err(jvm.exception("java/io/IOException", "I/O error").await);
+        }
 
         Ok(())
     }
@@ -156,7 +160,9 @@ impl RandomAccessFile {
         let fd = jvm.get_field(&this, "fd", "Ljava/io/FileDescriptor;").await?;
         let mut rust_file = FileDescriptor::file(jvm, context, fd).await?;
 
-        rust_file.seek(pos as _).await.unwrap();
+        if rust_file.seek(pos as _).await.is_err() {
+            return Err(jvm.exception("java/io/IOException", "I/O error").await);
+        }
 
         Ok(())
     }
@@ -167,7 +173,9 @@ impl RandomAccessFile {
         let fd = jvm.get_field(&this, "fd", "Ljava/io/FileDescriptor;").await?;
         let mut rust_file = FileDescriptor::file(jvm, context, fd).await?;
 
-        rust_file.set_len(new_length as _).await.unwrap();
+        if rust_file.set_len(new_length as _).await.is_err() {
+            return Err(jvm.exception("java/io/IOException", "I/O error").await);
+        }
 
         Ok(())
     }
@@ -178,7 +186,10 @@ impl RandomAccessFile {
         let fd = jvm.get_field(&this, "fd", "Ljava/io/FileDescriptor;").await?;
         let rust_file = FileDescriptor::file(jvm, context, fd).await?;
 
-        let len = rust_file.metadata().await.unwrap().size;
+        let Ok(metadata) = rust_file.metadata().await else {
+            return Err(jvm.exception("java/io/IOException", "I/O error").await);
+        };
+        let len = metadata.size;
 
         Ok(len as i64)
     }
@@ -189,7 +200,9 @@ impl RandomAccessFile {
         let fd = jvm.get_field(&this, "fd", "Ljava/io/FileDescriptor;").await?;
         let rust_file = FileDescriptor::file(jvm, context, fd).await?;
 
-        let pos = rust_file.tell().await.unwrap();
+        let Ok(pos) = rust_file.tell().await else {
+            return Err(jvm.exception("java/io/IOException", "I/O error").await);
+        };
 
         Ok(pos as i64)
     }

java_runtime/src/classes/java/lang.rs

@@ -5,6 +5,7 @@ mod array_store_exception;
 mod class;
 mod class_cast_exception;
 mod class_loader;
+mod class_not_found_exception;
 mod clone_not_supported_exception;
 mod cloneable;
 mod comparable;
@@ -41,14 +42,14 @@ mod unsupported_operation_exception;
 pub use self::{
     abstract_method_error::AbstractMethodError, arithmetic_exception::ArithmeticException,
     array_index_out_of_bounds_exception::ArrayIndexOutOfBoundsException, array_store_exception::ArrayStoreException, class::Class,
-    class_cast_exception::ClassCastException, class_loader::ClassLoader, clone_not_supported_exception::CloneNotSupportedException,
-    cloneable::Cloneable, comparable::Comparable, error::Error, exception::Exception, exception_in_initializer_error::ExceptionInInitializerError,
-    illegal_argument_exception::IllegalArgumentException, incompatible_class_change_error::IncompatibleClassChangeError,
-    index_out_of_bounds_exception::IndexOutOfBoundsException, instantiation_error::InstantiationError, integer::Integer,
-    interrupted_exception::InterruptedException, linkage_error::LinkageError, math::Math, negative_array_size_exception::NegativeArraySizeException,
-    no_class_def_found_error::NoClassDefFoundError, no_such_field_error::NoSuchFieldError, no_such_method_error::NoSuchMethodError,
-    null_pointer_exception::NullPointerException, number_format_exception::NumberFormatException, object::Object, runnable::Runnable,
-    runtime::Runtime, runtime_exception::RuntimeException, security_exception::SecurityException, string::String, string_buffer::StringBuffer,
-    string_index_out_of_bounds_exception::StringIndexOutOfBoundsException, system::System, thread::Thread, throwable::Throwable,
-    unsupported_operation_exception::UnsupportedOperationException,
+    class_cast_exception::ClassCastException, class_loader::ClassLoader, class_not_found_exception::ClassNotFoundException,
+    clone_not_supported_exception::CloneNotSupportedException, cloneable::Cloneable, comparable::Comparable, error::Error, exception::Exception,
+    exception_in_initializer_error::ExceptionInInitializerError, illegal_argument_exception::IllegalArgumentException,
+    incompatible_class_change_error::IncompatibleClassChangeError, index_out_of_bounds_exception::IndexOutOfBoundsException,
+    instantiation_error::InstantiationError, integer::Integer, interrupted_exception::InterruptedException, linkage_error::LinkageError, math::Math,
+    negative_array_size_exception::NegativeArraySizeException, no_class_def_found_error::NoClassDefFoundError, no_such_field_error::NoSuchFieldError,
+    no_such_method_error::NoSuchMethodError, null_pointer_exception::NullPointerException, number_format_exception::NumberFormatException,
+    object::Object, runnable::Runnable, runtime::Runtime, runtime_exception::RuntimeException, security_exception::SecurityException, string::String,
+    string_buffer::StringBuffer, string_index_out_of_bounds_exception::StringIndexOutOfBoundsException, system::System, thread::Thread,
+    throwable::Throwable, unsupported_operation_exception::UnsupportedOperationException,
 };

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

@@ -103,8 +103,10 @@ impl Class {
 
         let rust_name = JavaLangString::to_rust_string(jvm, &name).await?;
         let qualified_name = rust_name.replace('.', "/");
-        let class = jvm.get_class(&qualified_name).unwrap().java_class();
 
-        Ok(class.into())
+        match jvm.resolve_class(&qualified_name).await {
+            Ok(class) => Ok(class.java_class().into()),
+            Err(_) => Err(jvm.exception("java/lang/ClassNotFoundException", &rust_name).await),
+        }
     }
 }

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

@@ -0,0 +1,43 @@
+use alloc::vec;
+
+use java_class_proto::JavaMethodProto;
+use jvm::{ClassInstanceRef, Jvm, Result};
+
+use crate::{RuntimeClassProto, RuntimeContext, classes::java::lang::String};
+
+// class java.lang.ClassNotFoundException
+pub struct ClassNotFoundException;
+
+impl ClassNotFoundException {
+    pub fn as_proto() -> RuntimeClassProto {
+        RuntimeClassProto {
+            name: "java/lang/ClassNotFoundException",
+            parent_class: Some("java/lang/Exception"),
+            interfaces: vec![],
+            methods: vec![
+                JavaMethodProto::new("<init>", "()V", Self::init, Default::default()),
+                JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_with_message, Default::default()),
+            ],
+            fields: vec![],
+            access_flags: Default::default(),
+        }
+    }
+
+    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
+        tracing::debug!("java.lang.ClassNotFoundException::<init>({this:?})");
+
+        let _: () = jvm.invoke_special(&this, "java/lang/Exception", "<init>", "()V", ()).await?;
+
+        Ok(())
+    }
+
+    async fn init_with_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, message: ClassInstanceRef<String>) -> Result<()> {
+        tracing::debug!("java.lang.ClassNotFoundException::<init>({this:?}, {message:?})");
+
+        let _: () = jvm
+            .invoke_special(&this, "java/lang/Exception", "<init>", "(Ljava/lang/String;)V", (message,))
+            .await?;
+
+        Ok(())
+    }
+}

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

@@ -379,9 +379,11 @@ impl String {
     async fn value_of_char(jvm: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<ClassInstanceRef<Self>> {
         tracing::debug!("java.lang.String::valueOf({value})");
 
-        let string = RustString::from_utf16(&[value]).unwrap();
+        // build through [C so an unpaired surrogate is preserved
+        let mut chars = jvm.instantiate_array("C", 1).await?;
+        jvm.store_array(&mut chars, 0, [value]).await?;
 
-        Ok(JavaLangString::from_rust_string(jvm, &string).await?.into())
+        Ok(jvm.new_class("java/lang/String", "([C)V", (chars,)).await?.into())
     }
 
     async fn value_of_integer(jvm: &Jvm, _: &mut RuntimeContext, value: i32) -> Result<ClassInstanceRef<Self>> {

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

@@ -1,8 +1,4 @@
-use alloc::{
-    string::{String as RustString, ToString},
-    vec,
-    vec::Vec,
-};
+use alloc::{string::ToString, vec, vec::Vec};
 
 use java_class_proto::{JavaFieldProto, JavaMethodProto};
 use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result, runtime::JavaLangString};
@@ -162,9 +158,7 @@ impl StringBuffer {
     async fn append_character(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: u16) -> Result<ClassInstanceRef<Self>> {
         tracing::debug!("java.lang.StringBuffer::append({this:?}, {value:?})");
 
-        let value = RustString::from_utf16(&[value]).unwrap();
-
-        Self::append(jvm, &mut this, &value).await?;
+        Self::append_utf16(jvm, &mut this, vec![value]).await?;
 
         Ok(this)
     }
@@ -180,9 +174,8 @@ impl StringBuffer {
         tracing::debug!("java.lang.StringBuffer::append({this:?}, {array:?}, {offset:?}, {length:?})");
 
         let value: Vec<JavaChar> = jvm.load_array(&array, offset as _, length as _).await?;
-        let string = RustString::from_utf16(&value).unwrap();
 
-        Self::append(jvm, &mut this, &string).await?;
+        Self::append_utf16(jvm, &mut this, value).await?;
 
         Ok(this)
     }
@@ -237,9 +230,12 @@ impl StringBuffer {
     }
 
     async fn append(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, string: &str) -> Result<()> {
+        Self::append_utf16(jvm, this, string.encode_utf16().collect()).await
+    }
+
+    async fn append_utf16(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, value_to_add: Vec<JavaChar>) -> Result<()> {
         let current_count: i32 = jvm.get_field(this, "count", "I").await?;
 
-        let value_to_add = string.encode_utf16().collect::<Vec<_>>();
         let count_to_add = value_to_add.len() as i32;
 
         StringBuffer::ensure_capacity(jvm, this, (current_count + count_to_add) as _).await?;

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

@@ -1,5 +1,6 @@
 mod zip_entry;
+mod zip_exception;
 mod zip_file;
 mod zip_file_entries;
 
-pub use {zip_entry::ZipEntry, zip_file::ZipFile, zip_file_entries::ZipFileEntries};
+pub use {zip_entry::ZipEntry, zip_exception::ZipException, zip_file::ZipFile, zip_file_entries::ZipFileEntries};