tests for BoolVector filter

Signed-off-by: Andrew Duffy <[email protected]>

Author: a10y

vortex-compute/src/filter/mod.rs

@@ -40,7 +40,7 @@ impl<'a> MaskIndices<'a> {
     /// # Safety
     ///
     /// The caller must ensure that the indices are strict-sorted, i.e. that they
-    /// are montonic and unique.
+    /// are monotonic and unique.
     ///
     /// Users of the `Indices` type assume this and failure to uphold this guarantee
     /// can result in UB downstream.

vortex-compute/src/filter/vector/bool.rs

@@ -42,3 +42,116 @@ where
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use vortex_buffer::BitBuffer;
+    use vortex_mask::Mask;
+    use vortex_vector::bool::BoolVectorMut;
+    use vortex_vector::{VectorMutOps, VectorOps};
+
+    use super::*;
+    use crate::filter::MaskIndices;
+
+    #[test]
+    fn test_filter_bool_vector_with_mask() {
+        let vec = BoolVectorMut::from_iter([true, false, true, false, true]).freeze();
+        let mask = Mask::from_iter([true, false, true, false, true]);
+
+        let filtered = vec.filter(&mask);
+
+        assert_eq!(filtered.len(), 3);
+        assert_eq!(filtered.validity().true_count(), 3);
+        assert_eq!(filtered.bits(), &BitBuffer::from_iter([true, true, true]));
+    }
+
+    #[test]
+    fn test_filter_bool_vector_with_mask_indices() {
+        let vec = BoolVectorMut::from_iter([true, false, true, false, true]).freeze();
+        let indices = unsafe { MaskIndices::new_unchecked(&[0, 2, 4]) };
+
+        let filtered = vec.filter(&indices);
+
+        assert_eq!(filtered.len(), 3);
+        assert_eq!(filtered.validity().true_count(), 3);
+        assert_eq!(filtered.bits(), &BitBuffer::from_iter([true, true, true]));
+    }
+
+    #[test]
+    fn test_filter_bool_vector_with_nulls() {
+        let vec =
+            BoolVectorMut::from_iter([Some(true), None, Some(false), Some(true), None]).freeze();
+        let mask = Mask::from_iter([true, true, false, true, false]);
+
+        let filtered = vec.filter(&mask);
+
+        assert_eq!(filtered.len(), 3);
+        assert_eq!(filtered.validity().true_count(), 2);
+
+        assert_eq!(
+            filtered.validity().to_bit_buffer(),
+            BitBuffer::from_iter([true, false, true])
+        );
+        assert_eq!(filtered.bits(), &BitBuffer::from_iter([true, false, true]));
+    }
+
+    #[test]
+    fn test_filter_bool_vector_all_true() {
+        let vec = BoolVectorMut::from_iter([true, false, true]).freeze();
+        let mask = Mask::new_true(3);
+
+        let filtered = vec.filter(&mask);
+
+        assert_eq!(filtered.len(), 3);
+        assert_eq!(filtered.bits(), &BitBuffer::from_iter([true, false, true]));
+    }
+
+    #[test]
+    fn test_filter_bool_vector_all_false() {
+        let vec = BoolVectorMut::from_iter([true, false, true]).freeze();
+        let mask = Mask::new_false(3);
+
+        let filtered = vec.filter(&mask);
+
+        assert_eq!(filtered.len(), 0);
+    }
+
+    #[test]
+    fn test_filter_bool_vector_mut_with_mask() {
+        let mut vec = BoolVectorMut::from_iter([true, false, true, false, true]);
+        let mask = Mask::from_iter([true, false, true, false, true]);
+
+        vec.filter(&mask);
+
+        assert_eq!(vec.len(), 3);
+        let frozen = vec.freeze();
+        assert_eq!(frozen.len(), 3);
+        assert_eq!(frozen.validity().true_count(), 3);
+    }
+
+    #[test]
+    fn test_filter_bool_vector_mut_with_mask_indices() {
+        let mut vec = BoolVectorMut::from_iter([true, false, true, false, true]);
+        let indices = unsafe { MaskIndices::new_unchecked(&[0, 2, 4]) };
+
+        vec.filter(&indices);
+
+        assert_eq!(vec.len(), 3);
+        let frozen = vec.freeze();
+        assert_eq!(frozen.len(), 3);
+        assert_eq!(frozen.validity().true_count(), 3);
+    }
+
+    #[test]
+    fn test_filter_bool_vector_mut_with_nulls() {
+        let mut vec = BoolVectorMut::from_iter([Some(true), None, Some(false), Some(true), None]);
+        let mask = Mask::from_iter([true, true, false, true, false]);
+
+        vec.filter(&mask);
+
+        assert_eq!(vec.len(), 3);
+        let frozen = vec.freeze();
+        assert_eq!(frozen.len(), 3);
+        assert_eq!(frozen.validity().true_count(), 2);
+    }
+}

vortex-vector/src/binaryview/scalar.rs

@@ -7,6 +7,7 @@ use crate::binaryview::{
 use crate::{Scalar, ScalarOps, VectorMutOps};
 
 /// A scalar value for types that implement [`BinaryViewType`].
+#[derive(Debug)]
 pub struct BinaryViewScalar<T: BinaryViewType>(Option<T::Scalar>);
 
 impl<T: BinaryViewType> From<Option<T::Scalar>> for BinaryViewScalar<T> {

vortex-vector/src/bool/scalar.rs

@@ -5,6 +5,7 @@ use crate::bool::BoolVectorMut;
 use crate::{Scalar, ScalarOps, VectorMut, VectorMutOps};
 
 /// A scalar value for boolean types.
+#[derive(Debug)]
 pub struct BoolScalar(Option<bool>);
 
 impl From<Option<bool>> for BoolScalar {

vortex-vector/src/decimal/scalar.rs

@@ -8,6 +8,7 @@ use crate::decimal::DVectorMut;
 use crate::{Scalar, ScalarOps, VectorMut, VectorMutOps};
 
 /// Represents a decimal scalar value.
+#[derive(Debug)]
 pub enum DecimalScalar {
     /// 8-bit decimal scalar.
     I8(DScalar<i8>),

vortex-vector/src/fixed_size_list/scalar.rs

@@ -10,6 +10,7 @@ use crate::{Scalar, ScalarOps, VectorMut, VectorOps};
 ///
 // NOTE(ngates): the reason we don't hold Option<Vector> representing the elements is that we
 //  wouldn't be able to go back to a vector using "repeat".
+#[derive(Debug)]
 pub struct FixedSizeListScalar(FixedSizeListVector);
 
 impl FixedSizeListScalar {

vortex-vector/src/listview/scalar.rs

@@ -7,6 +7,7 @@ use crate::{Scalar, ScalarOps, VectorMut, VectorOps};
 /// A scalar value for list view types.
 ///
 /// The inner value is a ListViewVector with length 1.
+#[derive(Debug)]
 pub struct ListViewScalar(ListViewVector);
 
 impl ListViewScalar {

vortex-vector/src/null/scalar.rs

@@ -5,6 +5,7 @@ use crate::null::NullVectorMut;
 use crate::{Scalar, ScalarOps, VectorMut};
 
 /// Represents a null scalar value.
+#[derive(Debug)]
 pub struct NullScalar;
 
 impl ScalarOps for NullScalar {

vortex-vector/src/primitive/scalar.rs

@@ -10,6 +10,7 @@ use crate::primitive::{PVectorMut, PrimitiveVectorMut};
 use crate::{Scalar, ScalarOps, VectorMut, VectorMutOps};
 
 /// Represents a primitive scalar value.
+#[derive(Debug)]
 pub enum PrimitiveScalar {
     /// 8-bit signed integer scalar
     I8(PScalar<i8>),

vortex-vector/src/scalar.rs

@@ -14,6 +14,7 @@ use crate::struct_::StructScalar;
 use crate::{ScalarOps, VectorMut, match_each_scalar};
 
 /// Represents a scalar value of any supported type.
+#[derive(Debug)]
 pub enum Scalar {
     /// Null scalars are always null.
     Null(NullScalar),