[simple] Write a test for GcVec

Mostly a copy of the "arrays" test.
It's even in the same file.

Author: Techcable

libs/simple/src/lib.rs

@@ -69,7 +69,7 @@ use crate::layout::{StaticGcType, GcType, SimpleVecRepr, DynamicObj, StaticVecTy
 use zerogc_context::collector::{RawSimpleAlloc, RawCollectorImpl};
 use zerogc_context::handle::{GcHandleList, RawHandleImpl};
 use zerogc_context::{CollectionManager as AbstractCollectionManager, RawContext as AbstractRawContext, CollectorContext};
-use zerogc::vec::{GcVec, GcRawVec};
+use zerogc::vec::{GcRawVec};
 
 #[cfg(feature = "small-object-arenas")]
 mod alloc;
@@ -136,6 +136,8 @@ pub type CollectorId = ::zerogc_context::CollectorId<RawSimpleCollector>;
 pub type Gc<'gc, T> = ::zerogc::Gc<'gc, T, CollectorId>;
 /// A garbage collected array, allocated in the "simple" collector
 pub type GcArray<'gc, T> = ::zerogc::vec::GcArray<'gc, T, CollectorId>;
+/// A garbage colelcted vector, allocated in the "simple" collector
+pub type GcVec<'gc, T> = ::zerogc::vec::GcVec<'gc, T, SimpleCollectorContext>;
 
 #[cfg(not(feature = "multiple-collectors"))]
 static GLOBAL_COLLECTOR: AtomicPtr<RawSimpleCollector> = AtomicPtr::new(std::ptr::null_mut());
@@ -164,7 +166,7 @@ unsafe impl RawSimpleAlloc for RawSimpleCollector {
         (context.collector().id(), ptr.cast())
     }
 
-    fn alloc_vec_with_capacity<'gc, T>(context: &'gc CollectorContext<Self>, capacity: usize) -> GcVec<'gc, T, CollectorContext<Self>> where T: GcSafe + 'gc {
+    fn alloc_vec_with_capacity<'gc, T>(context: &'gc CollectorContext<Self>, capacity: usize) -> GcVec<'gc, T> where T: GcSafe + 'gc {
         let ptr = if capacity == 0 {
             NonNull::dangling()
         } else {

libs/simple/tests/arrays.rs

@@ -4,7 +4,8 @@ use zerogc::GcSimpleAlloc;
 use zerogc::safepoint;
 use zerogc_derive::Trace;
 
-use zerogc_simple::{SimpleCollector, GcArray, Gc, CollectorId as SimpleCollectorId, GcConfig};
+use zerogc_simple::{SimpleCollector, GcArray, GcVec, Gc, CollectorId as SimpleCollectorId, GcConfig};
+use zerogc::vec::GcRawVec;
 
 fn test_collector() -> SimpleCollector {
     let mut config = GcConfig::default();
@@ -22,7 +23,7 @@ struct Dummy<'gc> {
 }
 
 #[test]
-fn int_array() {
+fn array() {
     let collector = test_collector();
     let mut context = collector.into_context();
     let array1 = context.alloc_slice_fill_copy(5, 12u32);
@@ -55,3 +56,47 @@ fn int_array() {
         }
     }
 }
+
+#[test]
+fn vec() {
+    let collector = test_collector();
+    let mut context = collector.into_context();
+    let mut vec1 = context.alloc_vec();
+    for _ in 0..5 {
+        vec1.push(12u32);
+    }
+    assert_eq!(*vec1.as_slice(), *vec![12u32; 5]);
+    drop(vec1);
+    safepoint!(context, ());
+    const TEXT: &[u8] = b"all cows eat grass";
+    let mut vec_text = context.alloc_vec();
+    vec_text.extend_from_slice(TEXT);
+    let mut vec_none: GcVec<Option<usize>> = context.alloc_vec_with_capacity(12);
+    for _ in 0..12 {
+        vec_none.push(None);
+    }
+    for val in vec_none.iter() {
+        assert_eq!(*val, None);
+    }
+    drop(vec_none);
+    let vec_text: GcVec<u8> = GcVec { raw: safepoint!(context, vec_text.into_raw()), context: &context };
+    assert_eq!(vec_text.as_slice(), TEXT);
+    let mut nested_trace: GcVec<Gc<Dummy>> = context.alloc_vec_with_capacity(3);
+    let mut last = None;
+    for i in 0..16 {
+        let obj = context.alloc(Dummy {
+            val: i,
+            inner: last
+        });
+        nested_trace.push(obj);
+        last = Some(obj);
+    }
+    drop(vec_text);
+    let nested_trace: GcVec<Gc<Dummy>> = GcVec{ raw: safepoint!(context, nested_trace.into_raw()), context: &context };
+    for (idx, val) in nested_trace.iter().enumerate() {
+        assert_eq!(val.val, idx, "Invalid val: {:?}", val);
+        if let Some(last) = val.inner {
+            assert_eq!(last.val, idx - 1);
+        }
+    }
+}