chore: add assert_nth_scalar! macro and simplify test assertions

encodings/fastlanes/src/bitpacking/vtable/operations.rs

@@ -58,6 +58,7 @@ mod test {
     use vortex_array::IntoArray;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
+    use vortex_array::assert_nth_scalar;
     use vortex_array::compute::take;
     use vortex_array::patches::Patches;
     use vortex_array::validity::Validity;
@@ -81,8 +82,8 @@ mod test {
         )
         .unwrap();
         let sliced = arr.slice(1024..2048).as_::<BitPackedVTable>().clone();
-        assert_eq!(sliced.scalar_at(0), (1024u32 % 64).into());
-        assert_eq!(sliced.scalar_at(1023), (2047u32 % 64).into());
+        assert_nth_scalar!(sliced, 0, 1024u32 % 64);
+        assert_nth_scalar!(sliced, 1023, 2047u32 % 64);
         assert_eq!(sliced.offset(), 0);
         assert_eq!(sliced.len(), 1024);
     }
@@ -96,8 +97,8 @@ mod test {
         .unwrap()
         .into_array();
         let sliced = arr.slice(512..1434).as_::<BitPackedVTable>().clone();
-        assert_eq!(sliced.scalar_at(0), (512u32 % 64).into());
-        assert_eq!(sliced.scalar_at(921), (1433u32 % 64).into());
+        assert_nth_scalar!(sliced, 0, 512u32 % 64);
+        assert_nth_scalar!(sliced, 921, 1433u32 % 64);
         assert_eq!(sliced.offset(), 512);
         assert_eq!(sliced.len(), 922);
     }
@@ -111,11 +112,8 @@ mod test {
         .unwrap();
 
         let compressed = packed.slice(768..9999);
-        assert_eq!(compressed.scalar_at(0), ((768 % 63) as u8).into());
-        assert_eq!(
-            compressed.scalar_at(compressed.len() - 1),
-            ((9998 % 63) as u8).into()
-        );
+        assert_nth_scalar!(compressed, 0, (768 % 63) as u8);
+        assert_nth_scalar!(compressed, compressed.len() - 1, (9998 % 63) as u8);
     }
 
     #[test]
@@ -127,11 +125,8 @@ mod test {
         .unwrap();
 
         let compressed = packed.slice(7168..9216);
-        assert_eq!(compressed.scalar_at(0), ((7168 % 63) as u8).into());
-        assert_eq!(
-            compressed.scalar_at(compressed.len() - 1),
-            ((9215 % 63) as u8).into()
-        );
+        assert_nth_scalar!(compressed, 0, (7168 % 63) as u8);
+        assert_nth_scalar!(compressed, compressed.len() - 1, (9215 % 63) as u8);
     }
 
     #[test]
@@ -143,13 +138,13 @@ mod test {
         .unwrap()
         .into_array();
         let sliced = arr.slice(512..1434).as_::<BitPackedVTable>().clone();
-        assert_eq!(sliced.scalar_at(0), (512u32 % 64).into());
-        assert_eq!(sliced.scalar_at(921), (1433u32 % 64).into());
+        assert_nth_scalar!(sliced, 0, 512u32 % 64);
+        assert_nth_scalar!(sliced, 921, 1433u32 % 64);
         assert_eq!(sliced.offset(), 512);
         assert_eq!(sliced.len(), 922);
         let doubly_sliced = sliced.slice(127..911).as_::<BitPackedVTable>().clone();
-        assert_eq!(doubly_sliced.scalar_at(0), ((512u32 + 127) % 64).into());
-        assert_eq!(doubly_sliced.scalar_at(783), ((512u32 + 910) % 64).into());
+        assert_nth_scalar!(doubly_sliced, 0, (512u32 + 127) % 64);
+        assert_nth_scalar!(doubly_sliced, 783, (512u32 + 910) % 64);
         assert_eq!(doubly_sliced.offset(), 639);
         assert_eq!(doubly_sliced.len(), 784);
     }

encodings/fastlanes/src/delta/array/delta_compress.rs

@@ -93,38 +93,32 @@ fn compress_primitive<T: NativePType + Delta + Transpose + WrappingSub, const LA
 #[cfg(test)]
 mod tests {
     use vortex_array::arrays::PrimitiveArray;
-    use vortex_dtype::NativePType;
+    use vortex_array::assert_arrays_eq;
 
-    use super::*;
     use crate::DeltaArray;
     use crate::delta::array::delta_decompress::delta_decompress;
 
     #[test]
     fn test_compress() {
-        do_roundtrip_test::<u32>((0u32..10_000).collect());
+        do_roundtrip_test((0u32..10_000).collect());
     }
 
     #[test]
     fn test_compress_nullable() {
-        do_roundtrip_test::<u32>(PrimitiveArray::from_option_iter(
+        do_roundtrip_test(PrimitiveArray::from_option_iter(
             (0u32..10_000).map(|i| (i % 2 == 0).then_some(i)),
         ));
     }
 
     #[test]
     fn test_compress_overflow() {
-        do_roundtrip_test::<u8>((0..10_000).map(|i| (i % (u8::MAX as i32)) as u8).collect());
+        do_roundtrip_test((0..10_000).map(|i| (i % (u8::MAX as i32)) as u8).collect());
     }
 
-    fn do_roundtrip_test<T: NativePType>(input: PrimitiveArray) {
+    fn do_roundtrip_test(input: PrimitiveArray) {
         let delta = DeltaArray::try_from_primitive_array(&input).unwrap();
         assert_eq!(delta.len(), input.len());
         let decompressed = delta_decompress(&delta);
-        let decompressed_slice = decompressed.as_slice::<T>();
-        assert_eq!(decompressed_slice.len(), input.len());
-        for (actual, expected) in decompressed_slice.iter().zip(input.as_slice()) {
-            assert_eq!(actual, expected);
-        }
-        assert_eq!(decompressed.validity(), input.validity());
+        assert_arrays_eq!(decompressed, input);
     }
 }

encodings/fsst/src/tests.rs

@@ -7,6 +7,7 @@ use vortex_array::IntoArray;
 use vortex_array::ToCanonical;
 use vortex_array::arrays::builder::VarBinBuilder;
 use vortex_array::assert_arrays_eq;
+use vortex_array::assert_nth_scalar;
 use vortex_array::compute::filter;
 use vortex_array::compute::take;
 use vortex_buffer::buffer;
@@ -18,12 +19,6 @@ use crate::FSSTVTable;
 use crate::fsst_compress;
 use crate::fsst_train_compressor;
 
-macro_rules! assert_nth_scalar {
-    ($arr:expr, $n:expr, $expected:expr) => {
-        assert_eq!($arr.scalar_at($n), $expected.try_into().unwrap());
-    };
-}
-
 /// this function is VERY slow on miri, so we only want to run it once
 pub(crate) fn build_fsst_array() -> ArrayRef {
     let mut input_array = VarBinBuilder::<i32>::with_capacity(3);

encodings/pco/src/test.rs

@@ -9,6 +9,7 @@ use vortex_array::arrays::BoolArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrow::compute::to_arrow_preferred;
 use vortex_array::assert_arrays_eq;
+use vortex_array::assert_nth_scalar;
 use vortex_array::serde::ArrayParts;
 use vortex_array::serde::SerializeOptions;
 use vortex_array::session::ArraySession;
@@ -25,12 +26,6 @@ use vortex_mask::Mask;
 use crate::PcoArray;
 use crate::PcoVTable;
 
-macro_rules! assert_nth_scalar {
-    ($arr:expr, $n:expr, $expected:expr) => {
-        assert_eq!($arr.scalar_at($n), $expected.try_into().unwrap());
-    };
-}
-
 #[test]
 fn test_compress_decompress() {
     let data: Vec<i32> = (0..200).collect();

encodings/zstd/src/test.rs

@@ -7,6 +7,7 @@ use vortex_array::arrays::BoolArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::VarBinViewArray;
 use vortex_array::assert_arrays_eq;
+use vortex_array::assert_nth_scalar;
 use vortex_array::validity::Validity;
 use vortex_array::vtable::ValidityHelper;
 use vortex_buffer::Alignment;
@@ -17,12 +18,6 @@ use vortex_mask::Mask;
 
 use crate::ZstdArray;
 
-macro_rules! assert_nth_scalar {
-    ($arr:expr, $n:expr, $expected:expr) => {
-        assert_eq!($arr.scalar_at($n), $expected.try_into().unwrap());
-    };
-}
-
 #[test]
 fn test_zstd_compress_decompress() {
     let data: Vec<i32> = (0..200).collect();
@@ -115,7 +110,6 @@ fn test_zstd_with_dict() {
 
     let decompressed = compressed.decompress().to_primitive();
     assert_arrays_eq!(decompressed, PrimitiveArray::from_iter(data));
-    assert_eq!(decompressed.validity(), array.validity());
 
     // check slicing works
     let slice = compressed.slice(176..179);

fuzz/src/array/mask.rs

@@ -131,11 +131,11 @@ mod tests {
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::StructArray;
     use vortex_array::arrays::VarBinViewArray;
+    use vortex_array::assert_arrays_eq;
     use vortex_dtype::DecimalDType;
     use vortex_dtype::FieldNames;
     use vortex_dtype::Nullability;
     use vortex_mask::Mask;
-    use vortex_scalar::Scalar;
 
     use super::mask_canonical_array;
 
@@ -160,12 +160,8 @@ mod tests {
 
         let result = mask_canonical_array(array.to_canonical(), &mask).unwrap();
 
-        assert_eq!(result.len(), 5);
-        assert!(!result.is_valid(0));
-        assert_eq!(result.scalar_at(1), Scalar::from(Some(false)));
-        assert_eq!(result.scalar_at(2), Scalar::from(Some(true)));
-        assert!(!result.is_valid(3));
-        assert_eq!(result.scalar_at(4), Scalar::from(Some(true)));
+        let expected = BoolArray::from_iter([None, Some(false), Some(true), None, Some(true)]);
+        assert_arrays_eq!(result, expected);
     }
 
     #[test]
@@ -175,12 +171,8 @@ mod tests {
 
         let result = mask_canonical_array(array.to_canonical(), &mask).unwrap();
 
-        assert_eq!(result.len(), 5);
-        assert_eq!(result.scalar_at(0), Scalar::from(Some(1)));
-        assert!(!result.is_valid(1));
-        assert_eq!(result.scalar_at(2), Scalar::from(Some(3)));
-        assert!(!result.is_valid(3));
-        assert_eq!(result.scalar_at(4), Scalar::from(Some(5)));
+        let expected = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), None, Some(5)]);
+        assert_arrays_eq!(result, expected);
     }
 
     #[test]
@@ -190,30 +182,24 @@ mod tests {
 
         let result = mask_canonical_array(array.to_canonical(), &mask).unwrap();
 
-        assert_eq!(result.len(), 5);
-        assert!(!result.is_valid(0));
-        assert!(!result.is_valid(1)); // was already null
-        assert_eq!(result.scalar_at(2), Scalar::from(Some(3)));
-        assert!(!result.is_valid(3));
-        assert!(!result.is_valid(4)); // was already null
+        let expected = PrimitiveArray::from_option_iter([None, None, Some(3i32), None, None]);
+        assert_arrays_eq!(result, expected);
     }
 
     #[test]
     fn test_mask_decimal_array() {
+        let dtype = DecimalDType::new(10, 2);
         let array = DecimalArray::from_option_iter(
             [Some(1i128), Some(2), Some(3), Some(4), Some(5)],
-            DecimalDType::new(10, 2),
+            dtype,
         );
         let mask = Mask::from_iter([false, false, true, false, false]);
 
         let result = mask_canonical_array(array.to_canonical(), &mask).unwrap();
 
-        assert_eq!(result.len(), 5);
-        assert!(result.is_valid(0));
-        assert!(result.is_valid(1));
-        assert!(!result.is_valid(2));
-        assert!(result.is_valid(3));
-        assert!(result.is_valid(4));
+        let expected =
+            DecimalArray::from_option_iter([Some(1i128), Some(2), None, Some(4), Some(5)], dtype);
+        assert_arrays_eq!(result, expected);
     }
 
     #[test]
@@ -223,18 +209,9 @@ mod tests {
 
         let result = mask_canonical_array(array.to_canonical(), &mask).unwrap();
 
-        assert_eq!(result.len(), 5);
-        assert!(!result.is_valid(0));
-        assert_eq!(
-            result.scalar_at(1),
-            Scalar::utf8("two", Nullability::Nullable)
-        );
-        assert!(!result.is_valid(2));
-        assert_eq!(
-            result.scalar_at(3),
-            Scalar::utf8("four", Nullability::Nullable)
-        );
-        assert!(!result.is_valid(4));
+        let expected =
+            VarBinViewArray::from_iter_nullable_str([None, Some("two"), None, Some("four"), None]);
+        assert_arrays_eq!(result, expected);
     }
 
     #[test]
@@ -304,11 +281,8 @@ mod tests {
 
         let result = mask_canonical_array(array.to_canonical(), &mask).unwrap();
 
-        assert_eq!(result.len(), 5);
-        // All values should be masked out (null)
-        for i in 0..5 {
-            assert!(!result.is_valid(i));
-        }
+        let expected = PrimitiveArray::from_option_iter([None, None, None, None, None::<i32>]);
+        assert_arrays_eq!(result, expected);
     }
 
     #[test]
@@ -318,14 +292,9 @@ mod tests {
 
         let result = mask_canonical_array(array.to_canonical(), &mask).unwrap();
 
-        assert_eq!(result.len(), 5);
-        // No values should be masked out
-        for i in 0..5 {
-            assert!(result.is_valid(i));
-            #[allow(clippy::cast_possible_truncation)]
-            let expected = (i + 1) as i32;
-            assert_eq!(result.scalar_at(i), Scalar::from(Some(expected)));
-        }
+        let expected =
+            PrimitiveArray::from_option_iter([Some(1i32), Some(2), Some(3), Some(4), Some(5)]);
+        assert_arrays_eq!(result, expected);
     }
 
     #[test]

vortex-array/src/arrays/assertions.rs

@@ -9,6 +9,23 @@ pub fn format_indices<I: IntoIterator<Item = usize>>(indices: I) -> impl Display
     indices.into_iter().format(",")
 }
 
+/// Asserts that the scalar at position `$n` in array `$arr` equals `$expected`.
+///
+/// This is a convenience macro for testing that avoids verbose scalar comparison code.
+///
+/// # Example
+/// ```ignore
+/// let arr = PrimitiveArray::from_iter([1, 2, 3]);
+/// assert_nth_scalar!(arr, 0, 1);
+/// assert_nth_scalar!(arr, 1, 2);
+/// ```
+#[macro_export]
+macro_rules! assert_nth_scalar {
+    ($arr:expr, $n:expr, $expected:expr) => {
+        assert_eq!($arr.scalar_at($n), $expected.try_into().unwrap());
+    };
+}
+
 #[macro_export]
 macro_rules! assert_arrays_eq {
     ($left:expr, $right:expr) => {{

vortex-array/src/arrays/chunked/tests.rs

@@ -102,8 +102,7 @@ fn scalar_at_empty_children_both_sides() {
         DType::Primitive(PType::U64, Nullability::NonNullable),
     )
     .unwrap();
-    assert_eq!(array.scalar_at(0), 1u64.into());
-    assert_eq!(array.scalar_at(1), 2u64.into());
+    assert_arrays_eq!(array, PrimitiveArray::from_iter([1u64, 2]));
 }
 
 #[test]
@@ -118,10 +117,7 @@ fn scalar_at_empty_children_trailing() {
         DType::Primitive(PType::U64, Nullability::NonNullable),
     )
     .unwrap();
-    assert_eq!(array.scalar_at(0), 1u64.into());
-    assert_eq!(array.scalar_at(1), 2u64.into());
-    assert_eq!(array.scalar_at(2), 3u64.into());
-    assert_eq!(array.scalar_at(3), 4u64.into());
+    assert_arrays_eq!(array, PrimitiveArray::from_iter([1u64, 2, 3, 4]));
 }
 
 #[test]
@@ -136,10 +132,7 @@ fn scalar_at_empty_children_leading() {
         DType::Primitive(PType::U64, Nullability::NonNullable),
     )
     .unwrap();
-    assert_eq!(array.scalar_at(0), 1u64.into());
-    assert_eq!(array.scalar_at(1), 2u64.into());
-    assert_eq!(array.scalar_at(2), 3u64.into());
-    assert_eq!(array.scalar_at(3), 4u64.into());
+    assert_arrays_eq!(array, PrimitiveArray::from_iter([1u64, 2, 3, 4]));
 }
 
 #[test]