Add clone exception

Author: dlunch

java_runtime/src/classes/java/lang.rs

@@ -1,6 +1,7 @@
 mod array_index_out_of_bounds_exception;
 mod class;
 mod class_loader;
+mod cloneable;
 mod error;
 mod exception;
 mod illegal_argument_exception;
@@ -15,6 +16,7 @@ mod no_class_def_found_error;
 mod no_such_field_error;
 mod no_such_method_error;
 mod null_pointer_exception;
+mod clone_not_supported_exception;
 mod object;
 mod runnable;
 mod runtime;
@@ -28,12 +30,12 @@ mod throwable;
 mod unsupported_operation_exception;
 
 pub use self::{
-    array_index_out_of_bounds_exception::ArrayIndexOutOfBoundsException, class::Class, class_loader::ClassLoader, error::Error, exception::Exception,
-    illegal_argument_exception::IllegalArgumentException, incompatible_class_change_error::IncompatibleClassChangeError,
+    array_index_out_of_bounds_exception::ArrayIndexOutOfBoundsException, class::Class, class_loader::ClassLoader, cloneable::Cloneable, error::Error,
+    exception::Exception, 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, no_class_def_found_error::NoClassDefFoundError,
     no_such_field_error::NoSuchFieldError, no_such_method_error::NoSuchMethodError, null_pointer_exception::NullPointerException, object::Object,
     runnable::Runnable, runtime::Runtime, runtime_exception::RuntimeException, security_exception::SecurityException, string::String,
     string_buffer::StringBuffer, system::System, thread::Thread, throwable::Throwable,
-    unsupported_operation_exception::UnsupportedOperationException,
+    unsupported_operation_exception::UnsupportedOperationException, clone_not_supported_exception::CloneNotSupportedException,
 };

java_runtime/src/classes/java/lang/clone_not_supported_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.CloneNotSupportedException
+pub struct CloneNotSupportedException;
+
+impl CloneNotSupportedException {
+    pub fn as_proto() -> RuntimeClassProto {
+        RuntimeClassProto {
+            name: "java/lang/CloneNotSupportedException",
+            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.CloneNotSupportedException::<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.CloneNotSupportedException::<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/cloneable.rs

@@ -0,0 +1,21 @@
+use alloc::vec;
+
+use java_constants::ClassAccessFlags;
+
+use crate::RuntimeClassProto;
+
+// interface java.lang.Cloneable
+pub struct Cloneable;
+
+impl Cloneable {
+    pub fn as_proto() -> RuntimeClassProto {
+        RuntimeClassProto {
+            name: "java/lang/Cloneable",
+            parent_class: None,
+            interfaces: vec![],
+            methods: vec![],
+            fields: vec![],
+            access_flags: ClassAccessFlags::INTERFACE,
+        }
+    }
+}

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

@@ -25,7 +25,7 @@ impl Object {
                 JavaMethodProto::new("getClass", "()Ljava/lang/Class;", Self::get_class, Default::default()),
                 JavaMethodProto::new("hashCode", "()I", Self::hash_code, Default::default()),
                 JavaMethodProto::new("equals", "(Ljava/lang/Object;)Z", Self::equals, Default::default()),
-                JavaMethodProto::new("clone", "()Ljava/lang/Object;", Self::java_clone, MethodAccessFlags::NATIVE),
+                JavaMethodProto::new("clone", "()Ljava/lang/Object;", Self::clone, MethodAccessFlags::NATIVE),
                 JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, Default::default()),
                 JavaMethodProto::new("notify", "()V", Self::notify, Default::default()),
                 JavaMethodProto::new("notifyAll", "()V", Self::notify_all, Default::default()),
@@ -80,9 +80,13 @@ impl Object {
         rust_this.equals(&*rust_other)
     }
 
-    async fn java_clone(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
+    async fn clone(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
         tracing::warn!("stub java.lang.Object::clone({:?})", &this);
 
+        if !jvm.is_instance(&**this, "java/lang/Cloneable") {
+            return Err(jvm.exception("java/lang/CloneNotSupportedException", "Cannot clone this object").await);
+        }
+
         Ok(None.into())
     }
 

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

@@ -9,7 +9,6 @@ use crate::RuntimeClassProto;
 pub struct Runnable;
 
 impl Runnable {
-    // TODO Create JavaInterfaceProto
     pub fn as_proto() -> RuntimeClassProto {
         RuntimeClassProto {
             name: "java/lang/Runnable",

java_runtime/src/loader.rs

@@ -34,6 +34,8 @@ pub fn get_runtime_class_proto(name: &str) -> Option<RuntimeClassProto> {
         crate::classes::java::lang::ArrayIndexOutOfBoundsException::as_proto(),
         crate::classes::java::lang::Class::as_proto(),
         crate::classes::java::lang::ClassLoader::as_proto(),
+        crate::classes::java::lang::Cloneable::as_proto(),
+        crate::classes::java::lang::CloneNotSupportedException::as_proto(),
         crate::classes::java::lang::Error::as_proto(),
         crate::classes::java::lang::Exception::as_proto(),
         crate::classes::java::lang::IllegalArgumentException::as_proto(),

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

@@ -1,12 +1,13 @@
 use core::{
+    panic,
     sync::atomic::{AtomicBool, Ordering},
     time::Duration,
 };
 
 use alloc::{boxed::Box, collections::btree_map::BTreeMap, sync::Arc};
 
 use java_runtime::{Runtime, SpawnCallback, classes::java::lang::Object};
-use jvm::{ClassInstanceRef, Jvm, Result};
+use jvm::{ClassInstanceRef, JavaError, Jvm, Result};
 
 use test_utils::{TestRuntime, create_test_jvm};
 
@@ -104,3 +105,21 @@ async fn test_wait_timeout() -> Result<()> {
 
     Ok(())
 }
+
+#[tokio::test]
+async fn test_clone_not_cloneable() -> Result<()> {
+    let runtime = TestRuntime::new(BTreeMap::new());
+    let jvm = create_test_jvm(runtime.clone()).await?;
+
+    let object = jvm.new_class("java/lang/Object", "()V", ()).await?;
+
+    let result: Result<ClassInstanceRef<Object>> = jvm.invoke_virtual(&object, "clone", "()Ljava/lang/Object;", ()).await;
+    let Err(JavaError::JavaException(java_exception)) = result else {
+        panic!("Expected JavaException, got {:?}", result);
+    };
+
+    let class_name = java_exception.class_definition().name();
+    assert_eq!(class_name, "java/lang/CloneNotSupportedException");
+
+    Ok(())
+}