chore: use assert_arrays_eq! instead of using buffer eq

encodings/alp/src/alp/array.rs

@@ -483,9 +483,11 @@ mod tests {
     use std::sync::LazyLock;
 
     use rstest::rstest;
+    use vortex_array::IntoArray;
     use vortex_array::ToCanonical;
     use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::assert_arrays_eq;
     use vortex_array::session::ArraySession;
     use vortex_array::vtable::ValidityHelper;
     use vortex_session::VortexSession;
@@ -516,13 +518,7 @@ mod tests {
         // Compare against the traditional array-based decompress path
         let expected = decompress_into_array(encoded);
 
-        assert_eq!(result_canonical.len(), size);
-
-        let result_primitive = result_canonical.into_primitive();
-        assert_eq!(
-            result_primitive.as_slice::<f32>(),
-            expected.as_slice::<f32>()
-        );
+        assert_arrays_eq!(result_canonical.into_array(), expected);
     }
 
     #[rstest]
@@ -546,13 +542,7 @@ mod tests {
         // Compare against the traditional array-based decompress path
         let expected = decompress_into_array(encoded);
 
-        assert_eq!(result_canonical.len(), size);
-
-        let result_primitive = result_canonical.into_primitive();
-        assert_eq!(
-            result_primitive.as_slice::<f64>(),
-            expected.as_slice::<f64>()
-        );
+        assert_arrays_eq!(result_canonical.into_array(), expected);
     }
 
     #[rstest]
@@ -582,13 +572,7 @@ mod tests {
         // Compare against the traditional array-based decompress path
         let expected = decompress_into_array(encoded);
 
-        assert_eq!(result_canonical.len(), size);
-
-        let result_primitive = result_canonical.into_primitive();
-        assert_eq!(
-            result_primitive.as_slice::<f64>(),
-            expected.as_slice::<f64>()
-        );
+        assert_arrays_eq!(result_canonical.into_array(), expected);
     }
 
     #[rstest]
@@ -616,21 +600,7 @@ mod tests {
         // Compare against the traditional array-based decompress path
         let expected = decompress_into_array(encoded);
 
-        assert_eq!(result_canonical.len(), size);
-
-        let result_primitive = result_canonical.into_primitive();
-        assert_eq!(
-            result_primitive.as_slice::<f32>(),
-            expected.as_slice::<f32>()
-        );
-
-        // Test validity masks match
-        for idx in 0..size {
-            assert_eq!(
-                result_primitive.validity().is_valid(idx),
-                expected.validity().is_valid(idx)
-            );
-        }
+        assert_arrays_eq!(result_canonical.into_array(), expected);
     }
 
     #[rstest]
@@ -661,21 +631,7 @@ mod tests {
         // Compare against the traditional array-based decompress path
         let expected = decompress_into_array(encoded);
 
-        assert_eq!(result_canonical.len(), size);
-
-        let result_primitive = result_canonical.into_primitive();
-        assert_eq!(
-            result_primitive.as_slice::<f64>(),
-            expected.as_slice::<f64>()
-        );
-
-        // Test validity masks match
-        for idx in 0..size {
-            assert_eq!(
-                result_primitive.validity().is_valid(idx),
-                expected.validity().is_valid(idx)
-            );
-        }
+        assert_arrays_eq!(result_canonical.into_array(), expected);
     }
 
     #[rstest]

encodings/alp/src/alp/compress.rs

@@ -224,8 +224,7 @@ mod tests {
     fn roundtrips_close_fractional() {
         let original = PrimitiveArray::from_iter([195.26274f32, 195.27837, -48.815685]);
         let alp_arr = alp_encode(&original, None).unwrap();
-        let decompressed = alp_arr.to_primitive();
-        assert_arrays_eq!(decompressed, original);
+        assert_arrays_eq!(alp_arr, original);
     }
 
     #[test]
@@ -363,10 +362,9 @@ mod tests {
         let encoded = alp_encode(&original, None).unwrap();
 
         let sliced_alp = encoded.slice(512..1024);
-        let decoded = sliced_alp.to_primitive();
 
-        let expected_slice = original.slice(512..1024).to_primitive();
-        assert_eq!(expected_slice.as_slice::<f32>(), decoded.as_slice::<f32>());
+        let expected_slice = original.slice(512..1024);
+        assert_arrays_eq!(sliced_alp, expected_slice);
     }
 
     #[test]
@@ -376,10 +374,9 @@ mod tests {
         let encoded = alp_encode(&original, None).unwrap();
 
         let sliced_alp = encoded.slice(512..1024);
-        let decoded = sliced_alp.to_primitive();
 
-        let expected_slice = original.slice(512..1024).to_primitive();
-        assert_eq!(expected_slice.as_slice::<f64>(), decoded.as_slice::<f64>());
+        let expected_slice = original.slice(512..1024);
+        assert_arrays_eq!(sliced_alp, expected_slice);
     }
 
     #[test]
@@ -393,10 +390,9 @@ mod tests {
         let encoded = alp_encode(&original, None).unwrap();
 
         let sliced_alp = encoded.slice(512..1024);
-        let decoded = sliced_alp.to_primitive();
 
-        let expected_slice = original.slice(512..1024).to_primitive();
-        assert_eq!(expected_slice.as_slice::<f64>(), decoded.as_slice::<f64>());
+        let expected_slice = original.slice(512..1024);
+        assert_arrays_eq!(sliced_alp, expected_slice);
         assert!(encoded.patches().is_some());
     }
 
@@ -414,10 +410,9 @@ mod tests {
         let encoded = alp_encode(&original, None).unwrap();
 
         let sliced_alp = encoded.slice(1023..1025);
-        let decoded = sliced_alp.to_primitive();
 
-        let expected_slice = original.slice(1023..1025).to_primitive();
-        assert_eq!(expected_slice.as_slice::<f64>(), decoded.as_slice::<f64>());
+        let expected_slice = original.slice(1023..1025);
+        assert_arrays_eq!(sliced_alp, expected_slice);
         assert!(encoded.patches().is_some());
     }
 
@@ -445,7 +440,7 @@ mod tests {
 
         assert!(encoded.patches().is_none());
         let decoded = decompress_into_array(encoded);
-        assert_eq!(array.as_slice::<f32>(), decoded.as_slice::<f32>());
+        assert_arrays_eq!(decoded, array);
     }
 
     #[test]
@@ -456,7 +451,7 @@ mod tests {
 
         assert!(encoded.patches().is_none());
         let decoded = decompress_into_array(encoded);
-        assert_eq!(array.as_slice::<f64>(), decoded.as_slice::<f64>());
+        assert_arrays_eq!(decoded, array);
     }
 
     #[test]
@@ -468,12 +463,12 @@ mod tests {
         values[3000] = f32::NEG_INFINITY;
         values[4500] = f32::INFINITY;
 
-        let array = PrimitiveArray::new(Buffer::from(values.clone()), Validity::NonNullable);
+        let array = PrimitiveArray::new(Buffer::from(values), Validity::NonNullable);
         let encoded = alp_encode(&array, None).unwrap();
 
         assert!(encoded.patches().is_some());
         let decoded = decompress_into_array(encoded);
-        assert_eq!(values.as_slice(), decoded.as_slice::<f32>());
+        assert_arrays_eq!(decoded, array);
     }
 
     #[test]

encodings/alp/src/alp_rd/compute/filter.rs

@@ -39,7 +39,6 @@ register_kernel!(FilterKernelAdapter(ALPRDVTable).lift());
 mod test {
     use rstest::rstest;
     use vortex_array::IntoArray;
-    use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::compute::conformance::filter::test_filter_conformance;
@@ -62,9 +61,7 @@ mod test {
         assert!(encoded.left_parts_patches().is_some());
 
         // The first two values need no patching
-        let filtered = filter(encoded.as_ref(), &Mask::from_iter([true, false, true]))
-            .unwrap()
-            .to_primitive();
+        let filtered = filter(encoded.as_ref(), &Mask::from_iter([true, false, true])).unwrap();
         assert_arrays_eq!(filtered, PrimitiveArray::from_iter([a, outlier]));
     }
 

encodings/datetime-parts/src/canonical.rs

@@ -115,6 +115,7 @@ mod test {
     use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::TemporalArray;
+    use vortex_array::assert_arrays_eq;
     use vortex_array::validity::Validity;
     use vortex_array::vtable::ValidityHelper;
     use vortex_buffer::buffer;
@@ -156,10 +157,7 @@ mod test {
             .temporal_values()
             .to_primitive();
 
-        assert_eq!(
-            primitive_values.as_slice::<i64>(),
-            milliseconds.as_slice::<i64>()
-        );
+        assert_arrays_eq!(primitive_values, milliseconds);
         assert_eq!(primitive_values.validity(), &validity);
     }
 }

encodings/fastlanes/src/bitpacking/array/bitpack_compress.rs

@@ -477,14 +477,14 @@ mod test {
         chunked.clone().append_to_builder(&mut primitive_builder);
         let ca_into = primitive_builder.finish();
 
-        assert_arrays_eq!(into_ca, ca_into.to_primitive());
+        assert_arrays_eq!(into_ca, ca_into);
 
         let mut primitive_builder =
             PrimitiveBuilder::<i32>::with_capacity(chunked.dtype().nullability(), 10 * 100);
         primitive_builder.extend_from_array(&chunked);
         let ca_into = primitive_builder.finish();
 
-        assert_arrays_eq!(into_ca, ca_into.to_primitive());
+        assert_arrays_eq!(into_ca, ca_into);
     }
 
     #[test]

encodings/fastlanes/src/bitpacking/array/bitpack_decompress.rs

@@ -224,8 +224,7 @@ mod tests {
     fn compression_roundtrip(n: usize) {
         let values = PrimitiveArray::from_iter((0..n).map(|i| (i % 2047) as u16));
         let compressed = BitPackedArray::encode(values.as_ref(), 11).unwrap();
-        let decompressed = compressed.to_primitive();
-        assert_arrays_eq!(decompressed, values);
+        assert_arrays_eq!(compressed, values);
 
         values
             .as_slice::<u16>()

encodings/fastlanes/src/bitpacking/array/mod.rs

@@ -282,6 +282,7 @@ mod test {
     use vortex_array::IntoArray;
     use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::assert_arrays_eq;
     use vortex_buffer::Buffer;
 
     use crate::BitPackedArray;
@@ -327,9 +328,9 @@ mod test {
 
         let packed_with_patches = BitPackedArray::encode(&parray, 9).unwrap();
         assert!(packed_with_patches.patches().is_some());
-        assert_eq!(
-            packed_with_patches.to_primitive().as_slice::<i32>(),
-            values.as_slice()
+        assert_arrays_eq!(
+            packed_with_patches.to_primitive(),
+            PrimitiveArray::new(values, vortex_array::validity::Validity::NonNullable)
         );
     }
 }

encodings/fastlanes/src/bitpacking/compute/cast.rs

@@ -58,7 +58,6 @@ register_kernel!(CastKernelAdapter(BitPackedVTable).lift());
 mod tests {
     use rstest::rstest;
     use vortex_array::IntoArray;
-    use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::compute::cast;
@@ -86,9 +85,8 @@ mod tests {
             &DType::Primitive(PType::U32, Nullability::NonNullable)
         );
 
-        let decoded = casted.to_primitive();
         assert_arrays_eq!(
-            decoded.as_ref(),
+            casted.as_ref(),
             PrimitiveArray::from_iter([10u32, 20, 30, 40, 50, 60])
         );
     }

encodings/fastlanes/src/bitpacking/compute/filter.rs

@@ -186,7 +186,7 @@ mod test {
 
         let mask = Mask::from_indices(bitpacked.len(), vec![0, 125, 2047, 2049, 2151, 2790]);
 
-        let primitive_result = filter(bitpacked.as_ref(), &mask).unwrap().to_primitive();
+        let primitive_result = filter(bitpacked.as_ref(), &mask).unwrap();
         assert_arrays_eq!(
             primitive_result,
             PrimitiveArray::from_iter([0u8, 62, 31, 33, 9, 18])
@@ -202,7 +202,7 @@ mod test {
 
         let mask = Mask::from_indices(sliced.len(), vec![1919, 1921]);
 
-        let primitive_result = filter(&sliced, &mask).unwrap().to_primitive();
+        let primitive_result = filter(&sliced, &mask).unwrap();
         assert_arrays_eq!(primitive_result, PrimitiveArray::from_iter([31u8, 33]));
     }
 

encodings/fastlanes/src/bitpacking/compute/take.rs

@@ -171,7 +171,7 @@ mod test {
         let unpacked = PrimitiveArray::from_iter((0..4096).map(|i| (i % 63) as u8));
         let bitpacked = BitPackedArray::encode(unpacked.as_ref(), 6).unwrap();
 
-        let primitive_result = take(bitpacked.as_ref(), &indices).unwrap().to_primitive();
+        let primitive_result = take(bitpacked.as_ref(), &indices).unwrap();
         assert_arrays_eq!(
             primitive_result,
             PrimitiveArray::from_iter([0u8, 62, 31, 33, 9, 18])
@@ -185,9 +185,7 @@ mod test {
 
         let indices = buffer![0, 2, 4, 6].into_array();
 
-        let primitive_result = take(bitpacked.as_ref(), indices.as_ref())
-            .unwrap()
-            .to_primitive();
+        let primitive_result = take(bitpacked.as_ref(), indices.as_ref()).unwrap();
         assert_arrays_eq!(primitive_result, PrimitiveArray::from_iter([0u32, 2, 4, 6]));
     }
 
@@ -200,7 +198,7 @@ mod test {
         let bitpacked = BitPackedArray::encode(unpacked.as_ref(), 6).unwrap();
         let sliced = bitpacked.slice(128..2050);
 
-        let primitive_result = take(&sliced, &indices).unwrap().to_primitive();
+        let primitive_result = take(&sliced, &indices).unwrap();
         assert_arrays_eq!(primitive_result, PrimitiveArray::from_iter([31u8, 33]));
     }
 
@@ -260,13 +258,12 @@ mod test {
             start.as_ref(),
             PrimitiveArray::from_option_iter([Some(0u64), Some(1), None, Some(3)]).as_ref(),
         )
-        .unwrap()
-        .to_primitive();
+        .unwrap();
         assert_arrays_eq!(
             taken_primitive,
             PrimitiveArray::from_option_iter([Some(1i32), Some(2), None, Some(4)])
         );
-        assert_eq!(taken_primitive.invalid_count(), 1);
+        assert_eq!(taken_primitive.to_primitive().invalid_count(), 1);
     }
 
     #[rstest]

encodings/fastlanes/src/delta/compute/cast.rs

@@ -50,7 +50,6 @@ register_kernel!(CastKernelAdapter(DeltaVTable).lift());
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
-    use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::compute::cast;
@@ -81,8 +80,7 @@ mod tests {
         );
 
         // Verify by decoding
-        let decoded = casted.to_primitive();
-        assert_arrays_eq!(decoded, PrimitiveArray::from_iter([10u32, 20, 30, 40, 50]));
+        assert_arrays_eq!(casted, PrimitiveArray::from_iter([10u32, 20, 30, 40, 50]));
     }
 
     #[test]