Add a couple more tests

src/highlevel/object_reference.rs

@@ -6,6 +6,7 @@ use crate::{
         class_object_reference::ReflectedType,
         string_reference::Value,
         thread_group_reference::{self, Children, Parent},
+        virtual_machine::DisposeObjects,
         ArrayID, ArrayRegion, ClassLoaderID, ClassObjectID, JdwpValue, ObjectID, StringID, Tag,
         TaggedObjectID, ThreadGroupID,
     },
@@ -18,7 +19,17 @@ use super::{
 
 pub type ObjectReference = PlainJvmObject<ObjectID>;
 
-impl ObjectReference {}
+impl ObjectReference {
+    pub fn dispose_single(&self) -> Result<(), ClientError> {
+        self.dispose(1)
+    }
+
+    pub fn dispose(&self, refcount: u32) -> Result<(), ClientError> {
+        self.client()
+            .get()
+            .send(DisposeObjects::new(&[(self.id(), refcount)]))
+    }
+}
 
 pub type JvmArray = ExtendedJvmObject<ArrayID>;
 

src/highlevel/reference_type.rs

@@ -132,7 +132,7 @@ impl ReferenceType {
             .send(SourceDebugExtension::new(self.id()))
     }
 
-    pub fn signature_with_generic(&self) -> Result<SignatureWithGenericReply, ClientError> {
+    pub fn signature_generic(&self) -> Result<SignatureWithGenericReply, ClientError> {
         self.client()
             .get()
             .send(SignatureWithGeneric::new(self.id()))
@@ -236,6 +236,27 @@ impl TaggedReferenceType {
         // SAFETY: Self and TypeTag fulfill the requirements
         unsafe { crate::spec::tag(self) }
     }
+
+    pub fn unwrap_class(self) -> ClassType {
+        match self {
+            TaggedReferenceType::Class(class) => class,
+            _ => panic!("Expected a class"),
+        }
+    }
+
+    pub fn unwrap_interface(self) -> InterfaceType {
+        match self {
+            TaggedReferenceType::Interface(interface) => interface,
+            _ => panic!("Expected an interface"),
+        }
+    }
+
+    pub fn unwrap_array(self) -> ArrayType {
+        match self {
+            TaggedReferenceType::Array(array) => array,
+            _ => panic!("Expected an array"),
+        }
+    }
 }
 
 impl Deref for TaggedReferenceType {

src/highlevel/vm.rs

@@ -162,7 +162,7 @@ impl VM {
             .send(virtual_machine::SetDefaultStratum::new(stratum))
     }
 
-    pub fn all_classes_with_generic(&self) -> Result<Vec<Class>, ClientError> {
+    pub fn all_classes_generic(&self) -> Result<Vec<Class>, ClientError> {
         let classes = self.client.get().send(AllClassesWithGeneric)?;
         let classes = classes
             .into_iter()

tests/array.rs

@@ -0,0 +1,48 @@
+use common::Result;
+
+mod common;
+
+#[test]
+fn length() -> Result {
+    let vm = common::launch_and_attach_vm("basic")?;
+    let (class_type, _) = vm.class_by_signature("[I")?;
+
+    let array_type = class_type.unwrap_array();
+    let array = array_type.new_instance(10)?;
+
+    assert_eq!(array.length()?, 10);
+
+    Ok(())
+}
+
+#[test]
+fn set_get_values() -> Result {
+    let vm = common::launch_and_attach_vm("basic")?;
+    let (class_type, _) = vm.class_by_signature("[I")?;
+
+    let array_type = class_type.unwrap_array();
+    let array = array_type.new_instance(10)?;
+
+    array.set_values(0, &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10])?;
+
+    let region = array.get_values(0, 10)?;
+
+    assert_snapshot!(region, @r###"
+    Int(
+        [
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+        ],
+    )
+    "###);
+
+    Ok(())
+}

tests/fixtures/Basic.java

@@ -1,11 +1,11 @@
 import java.util.HashMap;
 import java.util.function.IntSupplier;
 
-class Basic implements IntSupplier {
+class Basic<T> implements IntSupplier {
 
     static int staticInt = 42;
-    public static Basic running = new Basic();
-    public static Basic secondInstance = new Basic();
+    public static Basic<String> running = new Basic<>();
+    public static Basic<?> secondInstance = new Basic<>();
 
     public long ticks = 0;
 
@@ -49,6 +49,9 @@ private static void ping(Object ignored) {
         // noop lol
     }
 
+    static <T extends IntSupplier> void withGeneric(int param1, T param2) {
+    }
+
     class NestedClass {
         float field;
     }