fix

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>

Author: joseph-isaacs

Cargo.lock

@@ -158,12 +158,12 @@ mod tests {
         let array = PrimitiveArray::from_option_iter([None, Some(1.234f32), None]);
         let encoded = alp_encode(&array, None).unwrap();
         assert!(encoded.patches().is_none());
-        let expected_encoded = PrimitiveArray::from_iter(vec![0i32, 1234, 0]);
+        let expected_encoded = PrimitiveArray::from_option_iter([None, Some(1234i32), None]);
         assert_arrays_eq!(encoded.encoded(), expected_encoded);
         assert_eq!(encoded.exponents(), Exponents { e: 9, f: 6 });
 
         let decoded = decompress(&encoded);
-        let expected = PrimitiveArray::from_iter(vec![0f32, 1.234f32, 0f32]);
+        let expected = PrimitiveArray::from_option_iter(vec![None, Some(1.234f32), None]);
         assert_arrays_eq!(decoded, expected);
     }
 
@@ -190,7 +190,8 @@ mod tests {
         let array = PrimitiveArray::new(values, Validity::from_iter([true, true, false, true]));
         let encoded = alp_encode(&array, None).unwrap();
         assert!(encoded.patches().is_none());
-        let expected_encoded = PrimitiveArray::from_iter(vec![1234i64, 2718, 1234, 4000]);
+        let expected_encoded =
+            PrimitiveArray::from_option_iter(buffer![Some(1234i64), Some(2718), None, Some(4000)]);
         assert_arrays_eq!(encoded.encoded(), expected_encoded);
         assert_eq!(encoded.exponents(), Exponents { e: 16, f: 13 });
 

encodings/alp/src/alp/compress.rs

@@ -45,10 +45,10 @@ register_kernel!(CastKernelAdapter(ALPVTable).lift());
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
-    use vortex_array::IntoArray;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::cast;
     use vortex_array::compute::conformance::cast::test_cast_conformance;
+    use vortex_array::{IntoArray, assert_arrays_eq};
     use vortex_buffer::buffer;
     use vortex_dtype::{DType, Nullability, PType};
 
@@ -98,7 +98,7 @@ mod tests {
         );
 
         let decoded = casted.to_canonical().into_primitive();
-        assert_eq!(decoded.as_slice::<i32>(), &[1i32, 2, 3, 4]);
+        assert_arrays_eq!(decoded, PrimitiveArray::from_iter([1i32, 2, 3, 4]));
     }
 
     #[rstest]

encodings/alp/src/alp/compute/cast.rs

@@ -265,8 +265,8 @@ impl CanonicalVTable<ALPRDVTable> for ALPRDVTable {
 #[cfg(test)]
 mod test {
     use rstest::rstest;
-    use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::{ToCanonical, assert_arrays_eq};
 
     use crate::{ALPRDFloat, alp_rd};
 
@@ -294,7 +294,6 @@ mod test {
 
         let decoded = rd_array.to_primitive();
 
-        let maybe_null_reals: Vec<T> = reals.into_iter().map(|v| v.unwrap_or_default()).collect();
-        assert_eq!(decoded.as_slice::<T>(), &maybe_null_reals);
+        assert_arrays_eq!(decoded, PrimitiveArray::from_option_iter(reals));
     }
 }

encodings/alp/src/alp_rd/array.rs

@@ -37,7 +37,7 @@ mod test {
     use vortex_array::compute::conformance::filter::test_filter_conformance;
     use vortex_array::compute::filter;
     use vortex_array::validity::Validity;
-    use vortex_array::{IntoArray, ToCanonical};
+    use vortex_array::{IntoArray, ToCanonical, assert_arrays_eq};
     use vortex_buffer::buffer;
     use vortex_mask::Mask;
 
@@ -57,7 +57,7 @@ mod test {
         let filtered = filter(encoded.as_ref(), &Mask::from_iter([true, false, true]))
             .unwrap()
             .to_primitive();
-        assert_eq!(filtered.as_slice::<T>(), &[a, outlier]);
+        assert_arrays_eq!(filtered, PrimitiveArray::from_iter([a, outlier]));
     }
 
     #[rstest]

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

@@ -48,10 +48,10 @@ register_kernel!(TakeKernelAdapter(ALPRDVTable).lift());
 #[cfg(test)]
 mod test {
     use rstest::rstest;
-    use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::conformance::take::test_take_conformance;
     use vortex_array::compute::take;
+    use vortex_array::{ToCanonical, assert_arrays_eq};
 
     use crate::{ALPRDFloat, RDEncoder};
 
@@ -78,7 +78,7 @@ mod test {
             .unwrap()
             .to_primitive();
 
-        assert_eq!(taken.as_slice::<T>(), &[a, outlier]);
+        assert_arrays_eq!(taken, PrimitiveArray::from_iter([a, outlier]));
     }
 
     #[rstest]
@@ -104,9 +104,10 @@ mod test {
         .unwrap()
         .to_primitive();
 
-        assert_eq!(taken.as_slice::<T>()[0], a);
-        assert_eq!(taken.as_slice::<T>()[1], outlier);
-        assert!(!taken.validity_mask().value(2));
+        assert_arrays_eq!(
+            taken,
+            PrimitiveArray::from_option_iter([Some(a), Some(outlier), None])
+        );
     }
 
     #[rstest]

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

@@ -148,7 +148,7 @@ mod tests {
 
         let res = compare(lhs.as_ref(), rhs.as_ref(), Operator::Eq).unwrap();
 
-        let expected = BoolArray::from_iter([false, false, true]).into_array();
+        let expected = BoolArray::from_iter([Some(false), Some(false), Some(true)]).into_array();
         assert_arrays_eq!(res, expected);
     }
 
@@ -202,15 +202,15 @@ mod tests {
         );
 
         let res = compare(lhs.as_ref(), rhs.as_ref(), Operator::Eq).unwrap();
-        let expected = BoolArray::from_iter([false, false, false]).into_array();
+        let expected = BoolArray::from_iter([Some(false), Some(false), Some(false)]).into_array();
         assert_arrays_eq!(res, expected);
 
         let res = compare(lhs.as_ref(), rhs.as_ref(), Operator::Gt).unwrap();
-        let expected = BoolArray::from_iter([true, true, true]).into_array();
+        let expected = BoolArray::from_iter([Some(true), Some(true), Some(true)]).into_array();
         assert_arrays_eq!(res, expected);
 
         let res = compare(lhs.as_ref(), rhs.as_ref(), Operator::Lt).unwrap();
-        let expected = BoolArray::from_iter([false, false, false]).into_array();
+        let expected = BoolArray::from_iter([Some(false), Some(false), Some(false)]).into_array();
         assert_arrays_eq!(res, expected);
 
         // This cannot be converted to a i32.
@@ -220,15 +220,15 @@ mod tests {
         );
 
         let res = compare(lhs.as_ref(), rhs.as_ref(), Operator::Eq).unwrap();
-        let expected = BoolArray::from_iter([false, false, false]).into_array();
+        let expected = BoolArray::from_iter([Some(false), Some(false), Some(false)]).into_array();
         assert_arrays_eq!(res, expected);
 
         let res = compare(lhs.as_ref(), rhs.as_ref(), Operator::Gt).unwrap();
-        let expected = BoolArray::from_iter([false, false, false]).into_array();
+        let expected = BoolArray::from_iter([Some(false), Some(false), Some(false)]).into_array();
         assert_arrays_eq!(res, expected);
 
         let res = compare(lhs.as_ref(), rhs.as_ref(), Operator::Lt).unwrap();
-        let expected = BoolArray::from_iter([true, true, true]).into_array();
+        let expected = BoolArray::from_iter([Some(true), Some(true), Some(true)]).into_array();
         assert_arrays_eq!(res, expected);
     }
 }

encodings/decimal-byte-parts/src/decimal_byte_parts/compute/compare.rs

@@ -38,7 +38,7 @@ mod tests {
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::cast;
     use vortex_array::compute::conformance::cast::test_cast_conformance;
-    use vortex_array::{IntoArray, ToCanonical};
+    use vortex_array::{IntoArray, ToCanonical, assert_arrays_eq};
     use vortex_buffer::buffer;
     use vortex_dtype::{DType, Nullability, PType};
 
@@ -61,7 +61,7 @@ mod tests {
         );
 
         let decoded = casted.to_primitive();
-        assert_eq!(decoded.as_slice::<i64>(), &[1i64, 2, 3, 2, 1]);
+        assert_arrays_eq!(decoded, PrimitiveArray::from_iter([1i64, 2, 3, 2, 1]));
     }
 
     #[test]
@@ -163,10 +163,7 @@ mod tests {
         // Verify values are unchanged
         let original_values = dict.to_primitive();
         let final_values = back_dict.to_primitive();
-        assert_eq!(
-            original_values.as_slice::<i32>(),
-            final_values.as_slice::<i32>()
-        );
+        assert_arrays_eq!(original_values, final_values);
     }
 
     #[rstest]

encodings/dict/src/compute/cast.rs

@@ -53,7 +53,7 @@ mod tests {
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::fill_null;
     use vortex_array::validity::Validity;
-    use vortex_array::{IntoArray, ToCanonical};
+    use vortex_array::{IntoArray, ToCanonical, assert_arrays_eq};
     use vortex_buffer::{BitBuffer, buffer};
     use vortex_dtype::Nullability;
     use vortex_error::VortexUnwrap;
@@ -79,7 +79,7 @@ mod tests {
         )
         .vortex_unwrap();
         let filled_primitive = filled.to_primitive();
-        assert_eq!(filled_primitive.as_slice::<i32>(), [10, 20, 20]);
+        assert_arrays_eq!(filled_primitive, PrimitiveArray::from_iter([10, 20, 20]));
         assert!(filled_primitive.all_valid());
     }
 }

encodings/dict/src/compute/fill_null.rs

@@ -563,8 +563,8 @@ pub mod test_harness {
 mod test {
     use rand::SeedableRng as _;
     use rand::rngs::StdRng;
-    use vortex_array::ToCanonical as _;
     use vortex_array::arrays::ChunkedArray;
+    use vortex_array::{ToCanonical as _, assert_arrays_eq};
     use vortex_buffer::{Buffer, buffer};
     use vortex_dtype::Nullability;
     use vortex_error::VortexError;
@@ -578,26 +578,23 @@ mod test {
         let zeros = buffer![0u16, 0, 0, 0].into_array().to_primitive();
         let bitpacked = bitpack_encode(&zeros, 0, None).unwrap();
         let actual = unpack(&bitpacked);
-        let actual = actual.as_slice::<u16>();
-        assert_eq!(actual, &[0u16, 0, 0, 0]);
+        assert_arrays_eq!(actual, PrimitiveArray::from_iter([0u16, 0, 0, 0]));
     }
 
     #[test]
     fn test_simple_patches() {
         let zeros = buffer![0u16, 1, 0, 1].into_array().to_primitive();
         let bitpacked = bitpack_encode(&zeros, 0, None).unwrap();
         let actual = unpack(&bitpacked);
-        let actual = actual.as_slice::<u16>();
-        assert_eq!(actual, &[0u16, 1, 0, 1]);
+        assert_arrays_eq!(actual, PrimitiveArray::from_iter([0u16, 1, 0, 1]));
     }
 
     #[test]
     fn test_one_full_chunk() {
         let zeros = BufferMut::from_iter(0u16..1024).into_array().to_primitive();
         let bitpacked = bitpack_encode(&zeros, 10, None).unwrap();
         let actual = unpack(&bitpacked);
-        let actual = actual.as_slice::<u16>();
-        assert_eq!(actual, &(0u16..1024).collect::<Vec<_>>());
+        assert_arrays_eq!(actual, PrimitiveArray::from_iter(0u16..1024));
     }
 
     #[test]
@@ -608,13 +605,9 @@ mod test {
         let bitpacked = bitpack_encode(&zeros, 10, None).unwrap();
         assert!(bitpacked.patches().is_some());
         let actual = unpack(&bitpacked);
-        let actual = actual.as_slice::<u16>();
-        assert_eq!(
+        assert_arrays_eq!(
             actual,
-            &(5u16..1029)
-                .chain(5u16..1029)
-                .chain(5u16..1029)
-                .collect::<Vec<_>>()
+            PrimitiveArray::from_iter((5u16..1029).chain(5u16..1029).chain(5u16..1029))
         );
     }
 
@@ -624,8 +617,7 @@ mod test {
         let bitpacked = bitpack_encode(&zeros, 11, None).unwrap();
         assert!(bitpacked.patches().is_none());
         let actual = unpack(&bitpacked);
-        let actual = actual.as_slice::<u16>();
-        assert_eq!(actual, &(0u16..1025).collect::<Vec<_>>());
+        assert_arrays_eq!(actual, PrimitiveArray::from_iter(0u16..1025));
     }
 
     #[test]
@@ -637,8 +629,7 @@ mod test {
         assert_eq!(bitpacked.len(), 1025);
         assert!(bitpacked.patches().is_some());
         let actual = unpack(&bitpacked);
-        let actual = actual.as_slice::<u16>();
-        assert_eq!(actual, &(512u16..1537).collect::<Vec<_>>());
+        assert_arrays_eq!(actual, PrimitiveArray::from_iter(512u16..1537));
     }
 
     #[test]
@@ -651,8 +642,7 @@ mod test {
         assert!(bitpacked.patches().is_some());
         let bitpacked = bitpacked.slice(1023..1025);
         let actual = unpack(bitpacked.as_::<BitPackedVTable>());
-        let actual = actual.as_slice::<u16>();
-        assert_eq!(actual, &[1535, 1536]);
+        assert_arrays_eq!(actual, PrimitiveArray::from_iter([1535u16, 1536]));
     }
 
     #[test]
@@ -665,8 +655,10 @@ mod test {
         assert!(bitpacked.patches().is_some());
         let bitpacked = bitpacked.slice(1023..2049);
         let actual = unpack(bitpacked.as_::<BitPackedVTable>());
-        let actual = actual.as_slice::<u16>();
-        assert_eq!(actual, &(1023..2049).map(|x| x + 512).collect::<Vec<_>>());
+        assert_arrays_eq!(
+            actual,
+            PrimitiveArray::from_iter((1023u16..2049).map(|x| x + 512))
+        );
     }
 
     #[test]
@@ -717,7 +709,7 @@ mod test {
         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_eq!(decompressed.as_slice::<u16>(), values.as_slice::<u16>());
+        assert_arrays_eq!(decompressed, values);
 
         values
             .as_slice::<u16>()
@@ -754,20 +746,14 @@ mod test {
         chunked.clone().append_to_builder(&mut primitive_builder);
         let ca_into = primitive_builder.finish();
 
-        assert_eq!(
-            into_ca.as_slice::<i32>(),
-            ca_into.to_primitive().as_slice::<i32>()
-        );
+        assert_arrays_eq!(into_ca, ca_into.to_primitive());
 
         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_eq!(
-            into_ca.as_slice::<i32>(),
-            ca_into.to_primitive().as_slice::<i32>()
-        );
+        assert_arrays_eq!(into_ca, ca_into.to_primitive());
     }
 
     #[test]
@@ -835,7 +821,7 @@ mod test {
         let result = builder.finish_into_primitive();
 
         // Verify all values were correctly unpacked including patches.
-        assert_eq!(result.as_slice::<u32>(), &values);
+        assert_arrays_eq!(result, PrimitiveArray::from_iter(values));
     }
 
     #[test]
@@ -858,7 +844,7 @@ mod test {
         // chunk 1 (1024-2047): no patches -> points to patch index 2
         // chunk 2 (2048-3071): patch at 3000 -> starts at patch index 2
         // chunk 3 (3072-4095): patch at 3100 -> starts at patch index 3
-        assert_eq!(chunk_offsets.as_slice::<u64>(), &[0, 2, 2, 3]);
+        assert_arrays_eq!(chunk_offsets, PrimitiveArray::from_iter([0u64, 2, 2, 3]));
     }
 
     #[test]
@@ -877,7 +863,7 @@ mod test {
         let patches = bitpacked.patches().unwrap();
         let chunk_offsets = patches.chunk_offsets().as_ref().unwrap().to_primitive();
 
-        assert_eq!(chunk_offsets.as_slice::<u64>(), &[0, 2, 2]);
+        assert_arrays_eq!(chunk_offsets, PrimitiveArray::from_iter([0u64, 2, 2]));
     }
 
     #[test]
@@ -901,7 +887,7 @@ mod test {
         // chunk 2 (2048-3071): no patches -> points to patch index 3
         // chunk 3 (3072-4095): no patches -> points to patch index 3 (remaining chunks filled)
         // chunk 4 (4096-5119): no patches -> points to patch index 3 (remaining chunks filled)
-        assert_eq!(chunk_offsets.as_slice::<u64>(), &[0, 2, 3, 3, 3]);
+        assert_arrays_eq!(chunk_offsets, PrimitiveArray::from_iter([0u64, 2, 3, 3, 3]));
     }
 
     #[test]
@@ -921,6 +907,6 @@ mod test {
         let chunk_offsets = patches.chunk_offsets().as_ref().unwrap().to_primitive();
 
         // Single chunk starting at patch index 0.
-        assert_eq!(chunk_offsets.as_slice::<u64>(), &[0]);
+        assert_arrays_eq!(chunk_offsets, PrimitiveArray::from_iter([0u64]));
     }
 }