add tests

Signed-off-by: Connor Tsui <connor.tsui20@gmail.com>

Author: connortsui20

vortex-vector/src/primitive/generic_mut.rs

@@ -15,9 +15,9 @@ use crate::{PVector, VectorMutOps, VectorOps};
 /// `T` is expected to be bound by [`NativePType`], which templates an internal [`BufferMut<T>`]
 /// that stores the elements of the vector.
 ///
-/// `PVectorMut<T>` is the primary way to construct primitive vectors. It provides efficient methods
-/// for building vectors incrementally before converting them to an immutable [`PVector<T>`] using
-/// the [`freeze`](crate::VectorMutOps::freeze) method.
+/// [`PVectorMut<T>`] is the primary way to construct primitive vectors. It provides efficient
+/// methods for building vectors incrementally before converting them to an immutable [`PVector<T>`]
+/// using the [`freeze`](crate::VectorMutOps::freeze) method.
 ///
 /// # Examples
 ///

vortex-vector/src/primitive/pvector_impl.rs

@@ -45,11 +45,17 @@ impl<T: NativePType> PVectorMut<T> {
         })
     }
 
-    /// Gets a nullable element at the given index.
+    /// Gets a nullable element at the given index, **WITHOUT** bounds checking.
     ///
     /// If the element at the given index is null, returns `None`. Otherwise, returns `Some(x)`,
     /// where `x: T`.
     ///
+    /// Note that this `get` method is different from the standard library [`slice::get`], which
+    /// returns `None` if the index is out of bounds. This method will panic if the index is out of
+    /// bounds, and return `None` if the elements is null.
+    ///
+    /// If you want bounds checking, use [`get_checked()`](Self::get_checked) instead.
+    ///
     /// # Panics
     ///
     /// Panics if the index is out of bounds.
@@ -130,23 +136,23 @@ impl<T: NativePType> PVectorMut<T> {
     /// Returns an immutable slice over the internal mutable buffer with elements of type `T`.
     ///
     /// Note that this slice may contain garbage data where the [`validity()`] mask from the frozen
-    /// [`PVector`] type states that an element is invalid.
+    /// [`PVector`](crate::PVector) type states that an element is invalid.
     ///
     /// The caller should check the frozen [`validity()`] before performing any operations.
     ///
-    /// [`validity()`]: PVector::validity
+    /// [`validity()`]: crate::PVector::validity
     pub fn as_slice(&self) -> &[T] {
         self.elements.as_slice()
     }
 
     /// Returns a mutable slice over the internal mutable buffer with elements of type `T`.
     ///
     /// Note that this slice may contain garbage data where the [`validity()`] mask from the frozen
-    /// [`PVector`] type states that an element is invalid.
+    /// [`PVector`](crate::PVector) type states that an element is invalid.
     ///
     /// The caller should check the frozen [`validity()`] before performing any operations.
     ///
-    /// [`validity()`]:  PVector::validity
+    /// [`validity()`]: crate::PVector::validity
     pub fn as_mut_slice(&mut self) -> &mut [T] {
         self.elements.as_mut_slice()
     }
@@ -287,3 +293,217 @@ impl<T: NativePType> FromIterator<T> for PVectorMut<T> {
         vec
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::VectorOps;
+
+    #[test]
+    fn test_first_last() {
+        let empty = PVectorMut::<i32>::with_capacity(0);
+        assert_eq!(empty.first(), None);
+        assert_eq!(empty.last(), None);
+
+        let single = PVectorMut::from_iter([Some(42)]);
+        assert_eq!(single.first(), Some(Some(42)));
+        assert_eq!(single.last(), Some(Some(42)));
+
+        let mixed = PVectorMut::from_iter([Some(1), None, Some(3), None, Some(5)]);
+        assert_eq!(mixed.first(), Some(Some(1)));
+        assert_eq!(mixed.last(), Some(Some(5)));
+
+        let null_first = PVectorMut::from_iter([None, Some(2i32)]);
+        assert_eq!(null_first.first(), Some(None));
+        assert_eq!(null_first.last(), Some(Some(2)));
+    }
+
+    #[test]
+    fn test_get_methods() {
+        let vec = PVectorMut::from_iter([Some(1), None, Some(3), None, Some(5)]);
+
+        // Test get_checked - bounds and nulls.
+        assert_eq!(vec.get_checked(0), Some(Some(1)));
+        assert_eq!(vec.get_checked(1), Some(None));
+        assert_eq!(vec.get_checked(5), None); // Out of bounds.
+
+        // Test get - nulls.
+        assert_eq!(vec.get(0), Some(1));
+        assert_eq!(vec.get(1), None);
+        assert_eq!(vec.get(2), Some(3));
+
+        // Test get_unchecked.
+        unsafe {
+            assert_eq!(vec.get_unchecked(0), 1);
+            assert_eq!(vec.get_unchecked(2), 3);
+            // Note: get_unchecked(1) would return default value but is safe.
+        }
+
+        // Also test PVector methods.
+        let frozen = vec.freeze();
+        assert_eq!(frozen.get_checked(0), Some(Some(1)));
+        assert_eq!(frozen.get(1), None);
+        unsafe {
+            assert_eq!(frozen.get_unchecked(2), 3);
+        }
+    }
+
+    #[test]
+    #[should_panic(expected = "index out of bounds")]
+    fn test_get_panic() {
+        let vec = PVectorMut::from_iter([Some(1), Some(2)]);
+        let _ = vec.get(10);
+    }
+
+    #[test]
+    fn test_push_variants() {
+        let mut vec = PVectorMut::<i32>::with_capacity(10);
+        vec.push(1);
+        vec.push_opt(None);
+        vec.push_opt(Some(3));
+
+        assert_eq!(vec.len(), 3);
+        assert_eq!(vec.get(0), Some(1));
+        assert_eq!(vec.get(1), None);
+        assert_eq!(vec.get(2), Some(3));
+
+        // Test push_unchecked with pre-reserved capacity.
+        vec.reserve(1);
+        unsafe {
+            vec.push_unchecked(4);
+        }
+        assert_eq!(vec.get(3), Some(4));
+    }
+
+    #[test]
+    fn test_resize_operations() {
+        let mut vec = PVectorMut::from_iter([1i32, 2, 3]);
+
+        // Grow with valid values.
+        vec.resize(5, Some(99));
+        assert_eq!(vec.len(), 5);
+        assert_eq!(vec.get(3), Some(99));
+        assert_eq!(vec.get(4), Some(99));
+
+        // Grow with nulls.
+        vec.resize(7, None);
+        assert_eq!(vec.get(5), None);
+        assert_eq!(vec.get(6), None);
+
+        // Shrink.
+        vec.resize(2, Some(0));
+        assert_eq!(vec.len(), 2);
+        assert_eq!(vec.get(0), Some(1));
+        assert_eq!(vec.get(1), Some(2));
+    }
+
+    #[test]
+    fn test_clear_truncate() {
+        let mut vec = PVectorMut::from_iter([Some(1), None, Some(3), None, Some(5)]);
+        let cap = vec.capacity();
+
+        vec.truncate(3);
+        assert_eq!(vec.len(), 3);
+        assert_eq!(vec.last(), Some(Some(3)));
+        assert!(vec.capacity() >= cap); // Capacity preserved.
+
+        vec.truncate(10); // Truncate beyond length - no-op.
+        assert_eq!(vec.len(), 3);
+
+        vec.clear();
+        assert_eq!(vec.len(), 0);
+        assert!(vec.capacity() >= cap); // Capacity still preserved.
+        assert_eq!(vec.first(), None);
+    }
+
+    #[test]
+    fn test_slice_access() {
+        let mut vec = PVectorMut::from_iter([Some(1i32), None, Some(3)]);
+        let slice = vec.as_slice();
+        assert_eq!(slice[0], 1);
+        assert_eq!(slice[2], 3);
+        // slice[1] is undefined for null but safe to access.
+
+        let mut_slice = vec.as_mut_slice();
+        mut_slice[0] = 10;
+        assert_eq!(vec.get(0), Some(10));
+
+        let frozen = vec.freeze();
+        assert_eq!(frozen.as_slice()[0], 10);
+    }
+
+    #[test]
+    fn test_from_iter_variants() {
+        // FromIterator<T> - all non-null.
+        let vec1 = PVectorMut::from_iter([1i32, 2, 3]);
+        assert_eq!(vec1.len(), 3);
+        assert!(vec1.freeze().validity().all_true());
+
+        // FromIterator<Option<T>> - mixed null/non-null.
+        let vec2 = PVectorMut::from_iter([Some(1i32), None, Some(3)]);
+        assert_eq!(vec2.len(), 3);
+        assert_eq!(vec2.freeze().validity().true_count(), 2);
+
+        // Empty iterators.
+        let empty1 = PVectorMut::from_iter::<[i32; 0]>([]);
+        let empty2 = PVectorMut::<i32>::from_iter(std::iter::empty::<Option<i32>>());
+        assert_eq!(empty1.len(), 0);
+        assert_eq!(empty2.len(), 0);
+    }
+
+    #[test]
+    fn test_extend_operations() {
+        let mut vec = PVectorMut::from_iter([1i32, 2]);
+
+        // Extend<T> - all non-null.
+        vec.extend([3, 4]);
+        assert_eq!(vec.len(), 4);
+        assert_eq!(vec.get(3), Some(4));
+
+        // Extend<Option<T>> - mixed null/non-null.
+        vec.extend([Some(5), None, Some(7)]);
+        assert_eq!(vec.len(), 7);
+        assert_eq!(vec.get(5), None);
+        assert_eq!(vec.get(6), Some(7));
+
+        // Extend with iterator that has size hint.
+        let iter = 8..10;
+        vec.extend(iter);
+        assert_eq!(vec.get(8), Some(9));
+    }
+
+    #[test]
+    fn test_empty_vector_edge_cases() {
+        let empty = PVectorMut::<i32>::with_capacity(0);
+        assert_eq!(empty.len(), 0);
+        assert_eq!(empty.first(), None);
+        assert_eq!(empty.last(), None);
+        assert_eq!(empty.get_checked(0), None);
+        assert_eq!(empty.as_slice().len(), 0);
+
+        let mut mutable_empty = PVectorMut::<i32>::with_capacity(0);
+        mutable_empty.clear(); // No-op on empty.
+        mutable_empty.truncate(0); // No-op.
+        mutable_empty.resize(0, None); // No-op.
+        assert_eq!(mutable_empty.len(), 0);
+    }
+
+    #[test]
+    fn test_complex_workflow() {
+        // Integration test combining multiple operations.
+        let mut vec = PVectorMut::<i32>::with_capacity(2);
+        vec.extend([1, 2]); // Extend<T>.
+        vec.push_opt(None);
+        vec.resize(5, Some(99));
+        vec.truncate(4);
+        vec.extend([Some(10), None]); // Extend<Option<T>>.
+
+        assert_eq!(vec.len(), 6);
+        let frozen = vec.freeze();
+        assert_eq!(frozen.validity().true_count(), 4);
+        assert_eq!(frozen.get(0), Some(1));
+        assert_eq!(frozen.get(2), None);
+        assert_eq!(frozen.get(3), Some(99));
+        assert_eq!(frozen.get(5), None);
+    }
+}