diff --git a/Cargo.lock b/Cargo.lock
index 11b61602873..156800423ba 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10295,6 +10295,7 @@ dependencies = [
  "tracing",
  "url",
  "vortex",
+ "vortex-array",
  "vortex-runend",
  "vortex-sequence",
  "vortex-utils",
diff --git a/encodings/alp/src/alp/array.rs b/encodings/alp/src/alp/array.rs
index aa2bb8605d0..a2348528313 100644
--- a/encodings/alp/src/alp/array.rs
+++ b/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]
diff --git a/encodings/alp/src/alp/compress.rs b/encodings/alp/src/alp/compress.rs
index d0d5d0dc089..c792bc8f37e 100644
--- a/encodings/alp/src/alp/compress.rs
+++ b/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]
diff --git a/encodings/alp/src/alp_rd/compute/filter.rs b/encodings/alp/src/alp_rd/compute/filter.rs
index be3a9109244..9bc965929fd 100644
--- a/encodings/alp/src/alp_rd/compute/filter.rs
+++ b/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]));
     }
 
diff --git a/encodings/datetime-parts/src/canonical.rs b/encodings/datetime-parts/src/canonical.rs
index d829c386bf7..5b650eeb92a 100644
--- a/encodings/datetime-parts/src/canonical.rs
+++ b/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);
     }
 }
diff --git a/encodings/fastlanes/src/bitpacking/array/bitpack_compress.rs b/encodings/fastlanes/src/bitpacking/array/bitpack_compress.rs
index e9a1619c37a..1634160c487 100644
--- a/encodings/fastlanes/src/bitpacking/array/bitpack_compress.rs
+++ b/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]
diff --git a/encodings/fastlanes/src/bitpacking/array/bitpack_decompress.rs b/encodings/fastlanes/src/bitpacking/array/bitpack_decompress.rs
index 290e2c63be8..2a7a69fe6e1 100644
--- a/encodings/fastlanes/src/bitpacking/array/bitpack_decompress.rs
+++ b/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>()
diff --git a/encodings/fastlanes/src/bitpacking/array/mod.rs b/encodings/fastlanes/src/bitpacking/array/mod.rs
index 9d7f2e46ec0..2e416762524 100644
--- a/encodings/fastlanes/src/bitpacking/array/mod.rs
+++ b/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)
         );
     }
 }
diff --git a/encodings/fastlanes/src/bitpacking/compute/cast.rs b/encodings/fastlanes/src/bitpacking/compute/cast.rs
index 5c240fbc1b6..8e1dfc15bac 100644
--- a/encodings/fastlanes/src/bitpacking/compute/cast.rs
+++ b/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])
         );
     }
diff --git a/encodings/fastlanes/src/bitpacking/compute/filter.rs b/encodings/fastlanes/src/bitpacking/compute/filter.rs
index a97a9793ab6..588a8e0f29d 100644
--- a/encodings/fastlanes/src/bitpacking/compute/filter.rs
+++ b/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]));
     }
 
diff --git a/encodings/fastlanes/src/bitpacking/compute/take.rs b/encodings/fastlanes/src/bitpacking/compute/take.rs
index b3d53396f74..e279327786d 100644
--- a/encodings/fastlanes/src/bitpacking/compute/take.rs
+++ b/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]
diff --git a/encodings/fastlanes/src/delta/compute/cast.rs b/encodings/fastlanes/src/delta/compute/cast.rs
index 443e5be8c06..8c14b763cb4 100644
--- a/encodings/fastlanes/src/delta/compute/cast.rs
+++ b/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]
diff --git a/encodings/fastlanes/src/for/array/for_compress.rs b/encodings/fastlanes/src/for/array/for_compress.rs
index 9af7b7941e6..842ecc1cd4e 100644
--- a/encodings/fastlanes/src/for/array/for_compress.rs
+++ b/encodings/fastlanes/src/for/array/for_compress.rs
@@ -67,8 +67,7 @@ mod test {
         let compressed = FoRArray::encode(array.clone()).unwrap();
         assert_eq!(i32::try_from(compressed.reference_scalar()).unwrap(), 1);
 
-        let decompressed = compressed.to_primitive();
-        assert_arrays_eq!(decompressed, array);
+        assert_arrays_eq!(compressed, array);
     }
 
     #[test]
@@ -107,8 +106,7 @@ mod test {
         // Create a range offset by a million.
         let array = PrimitiveArray::from_iter((0u32..100_000).step_by(1024).map(|v| v + 1_000_000));
         let compressed = FoRArray::encode(array.clone()).unwrap();
-        let decompressed = compressed.to_primitive();
-        assert_arrays_eq!(decompressed, array);
+        assert_arrays_eq!(compressed, array);
     }
 
     #[test]
@@ -118,8 +116,7 @@ mod test {
         let array = PrimitiveArray::from_iter((0u32..1024).map(|x| x % 7));
         let bp = BitPackedArray::encode(array.as_ref(), 3).unwrap();
         let compressed = FoRArray::try_new(bp.into_array(), 10u32.into()).unwrap();
-        let decompressed = compressed.to_primitive();
-        assert_arrays_eq!(decompressed, expect);
+        assert_arrays_eq!(compressed, expect);
     }
 
     #[test]
diff --git a/encodings/fastlanes/src/for/compute/cast.rs b/encodings/fastlanes/src/for/compute/cast.rs
index 39103b5776b..07456e4b4a5 100644
--- a/encodings/fastlanes/src/for/compute/cast.rs
+++ b/encodings/fastlanes/src/for/compute/cast.rs
@@ -36,7 +36,6 @@ register_kernel!(CastKernelAdapter(FoRVTable).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;
@@ -68,9 +67,8 @@ mod tests {
         );
 
         // Verify the values after decoding
-        let decoded = casted.to_primitive();
         assert_arrays_eq!(
-            decoded,
+            casted,
             PrimitiveArray::from_iter([100i64, 110, 120, 130, 140])
         );
     }
diff --git a/encodings/fastlanes/src/rle/array/mod.rs b/encodings/fastlanes/src/rle/array/mod.rs
index afff56342df..468e3e02983 100644
--- a/encodings/fastlanes/src/rle/array/mod.rs
+++ b/encodings/fastlanes/src/rle/array/mod.rs
@@ -218,6 +218,7 @@ mod tests {
     use vortex_array::IntoArray;
     use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::assert_arrays_eq;
     use vortex_array::serde::ArrayParts;
     use vortex_array::serde::SerializeOptions;
     use vortex_array::validity::Validity;
@@ -431,7 +432,6 @@ mod tests {
         assert_eq!(rle_array.len(), 2048);
 
         let original_data = rle_array.to_primitive();
-        let original_values = original_data.as_slice::<u32>();
 
         let ctx = ArrayContext::empty().with(RLEVTable.as_vtable());
         let serialized = rle_array
@@ -455,9 +455,8 @@ mod tests {
             .unwrap();
 
         let decoded_data = decoded.to_primitive();
-        let decoded_values = decoded_data.as_slice::<u32>();
 
-        assert_eq!(original_values, decoded_values);
+        assert_arrays_eq!(original_data, decoded_data);
     }
 
     #[test]
@@ -484,9 +483,6 @@ mod tests {
         let original_data = sliced.to_primitive();
         let decoded_data = decoded.to_primitive();
 
-        let original_values = original_data.as_slice::<u32>();
-        let decoded_values = decoded_data.as_slice::<u32>();
-
-        assert_eq!(original_values, decoded_values);
+        assert_arrays_eq!(original_data, decoded_data);
     }
 }
diff --git a/encodings/fastlanes/src/rle/array/rle_compress.rs b/encodings/fastlanes/src/rle/array/rle_compress.rs
index 3f3cc6f0871..f04dca635c1 100644
--- a/encodings/fastlanes/src/rle/array/rle_compress.rs
+++ b/encodings/fastlanes/src/rle/array/rle_compress.rs
@@ -215,10 +215,9 @@ mod tests {
         let array = values.into_array();
 
         let encoded = RLEArray::encode(&array.to_primitive()).unwrap();
-        let decoded = encoded.to_primitive();
 
         assert_eq!(encoded.len(), 1500);
-        assert_arrays_eq!(decoded, array);
+        assert_arrays_eq!(encoded, array);
         // 2 chunks: 1024 + 476 elements
         assert_eq!(encoded.values_idx_offsets().len(), 2);
     }
@@ -230,10 +229,9 @@ mod tests {
         let array = values.into_array();
 
         let encoded = RLEArray::encode(&array.to_primitive()).unwrap();
-        let decoded = encoded.to_primitive();
 
         assert_eq!(encoded.len(), 2048);
-        assert_arrays_eq!(decoded, array);
+        assert_arrays_eq!(encoded, array);
         assert_eq!(encoded.values_idx_offsets().len(), 2);
     }
 
diff --git a/encodings/pco/src/array.rs b/encodings/pco/src/array.rs
index 2b1220138a5..6d265901995 100644
--- a/encodings/pco/src/array.rs
+++ b/encodings/pco/src/array.rs
@@ -569,7 +569,6 @@ impl VisitorVTable<PcoVTable> for PcoVTable {
 #[cfg(test)]
 mod tests {
     use vortex_array::IntoArray;
-    use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::validity::Validity;
@@ -585,9 +584,8 @@ mod tests {
             Validity::from_iter([false, true, true, true, true, false]),
         );
         let pco = PcoArray::from_primitive(&values, 0, 128).unwrap();
-        let decoded = pco.to_primitive();
         assert_arrays_eq!(
-            decoded,
+            pco,
             PrimitiveArray::from_option_iter([
                 None,
                 Some(20u32),
@@ -604,6 +602,5 @@ mod tests {
             PrimitiveArray::from_option_iter([Some(20u32), Some(30), Some(40), Some(50)])
                 .into_array();
         assert_arrays_eq!(sliced, expected);
-        assert_arrays_eq!(sliced.to_canonical().into_array(), expected);
     }
 }
diff --git a/encodings/pco/src/compute/cast.rs b/encodings/pco/src/compute/cast.rs
index 35536624bf8..2be9e55f227 100644
--- a/encodings/pco/src/compute/cast.rs
+++ b/encodings/pco/src/compute/cast.rs
@@ -55,7 +55,6 @@ register_kernel!(CastKernelAdapter(PcoVTable).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;
@@ -86,10 +85,10 @@ mod tests {
             &DType::Primitive(PType::F64, Nullability::NonNullable)
         );
 
-        let decoded = casted.to_primitive();
-        let f64_values = decoded.as_slice::<f64>();
-        assert_eq!(f64_values.len(), 5);
-        assert!((f64_values[0] - 1.0).abs() < f64::EPSILON);
+        assert_arrays_eq!(
+            casted,
+            PrimitiveArray::from_iter([1.0f64, 2.0, 3.0, 4.0, 5.0])
+        );
     }
 
     #[test]
@@ -130,9 +129,7 @@ mod tests {
             &DType::Primitive(PType::U32, Nullability::NonNullable)
         );
         // Verify the values are correct
-        let decoded = casted.to_primitive();
-        let u32_values = decoded.as_slice::<u32>();
-        assert_eq!(u32_values, &[20, 30, 40, 50]);
+        assert_arrays_eq!(casted, PrimitiveArray::from_iter([20u32, 30, 40, 50]));
     }
 
     #[test]
@@ -156,9 +153,7 @@ mod tests {
             casted.dtype(),
             &DType::Primitive(PType::U32, Nullability::NonNullable)
         );
-        let decoded = casted.to_primitive();
-        let expected = PrimitiveArray::from_iter([20u32, 30, 40, 50]);
-        assert_arrays_eq!(decoded, expected);
+        assert_arrays_eq!(casted, PrimitiveArray::from_iter([20u32, 30, 40, 50]));
     }
 
     #[rstest]
diff --git a/encodings/pco/src/test.rs b/encodings/pco/src/test.rs
index 9c4e96090c5..8af9ec4e159 100644
--- a/encodings/pco/src/test.rs
+++ b/encodings/pco/src/test.rs
@@ -48,15 +48,10 @@ fn test_compress_decompress() {
     for i in 0_i32..5 {
         assert_nth_scalar!(slice, i as usize, 100 + i);
     }
-    let primitive = slice.to_primitive();
-    assert_arrays_eq!(
-        primitive,
-        PrimitiveArray::from_iter([100, 101, 102, 103, 104])
-    );
+    assert_arrays_eq!(slice, PrimitiveArray::from_iter([100, 101, 102, 103, 104]));
 
     let slice = compressed.slice(200..200);
-    let primitive = slice.to_primitive();
-    assert_arrays_eq!(primitive, PrimitiveArray::from_iter(Vec::<i32>::new()));
+    assert_arrays_eq!(slice, PrimitiveArray::from_iter(Vec::<i32>::new()));
 }
 
 #[test]
diff --git a/encodings/runend/src/compute/cast.rs b/encodings/runend/src/compute/cast.rs
index 5663e42504a..0cf19f32ff7 100644
--- a/encodings/runend/src/compute/cast.rs
+++ b/encodings/runend/src/compute/cast.rs
@@ -133,12 +133,7 @@ mod tests {
         let sliced = runend.slice(3..8);
 
         // Verify the slice is correct before casting
-        let sliced_decoded = sliced.to_primitive();
-        assert_eq!(sliced_decoded.len(), 5);
-        assert_arrays_eq!(
-            sliced_decoded,
-            PrimitiveArray::from_iter([200, 200, 300, 300, 300])
-        );
+        assert_arrays_eq!(sliced, PrimitiveArray::from_iter([200, 200, 300, 300, 300]));
 
         // Cast the sliced array
         let casted = cast(
@@ -148,10 +143,8 @@ mod tests {
         .unwrap();
 
         // Verify the cast preserved the offset
-        let casted_decoded = casted.to_primitive();
-        assert_eq!(casted_decoded.len(), 5);
         assert_arrays_eq!(
-            casted_decoded,
+            casted,
             PrimitiveArray::from_iter([200i64, 200, 300, 300, 300])
         );
     }
diff --git a/encodings/runend/src/compute/filter.rs b/encodings/runend/src/compute/filter.rs
index 821b0bc54c3..191adfddfa8 100644
--- a/encodings/runend/src/compute/filter.rs
+++ b/encodings/runend/src/compute/filter.rs
@@ -144,6 +144,7 @@ mod tests {
     use vortex_array::IntoArray;
     use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::assert_arrays_eq;
     use vortex_mask::Mask;
 
     use super::filter_run_end;
@@ -169,13 +170,13 @@ mod tests {
         .unwrap();
         let filtered_run_end = filtered.as_::<RunEndVTable>();
 
-        assert_eq!(
-            filtered_run_end.ends().to_primitive().as_slice::<u8>(),
-            [2, 4]
+        assert_arrays_eq!(
+            filtered_run_end.ends().to_primitive(),
+            PrimitiveArray::from_iter([2u8, 4])
         );
-        assert_eq!(
-            filtered_run_end.values().to_primitive().as_slice::<i32>(),
-            [1, 5]
+        assert_arrays_eq!(
+            filtered_run_end.values().to_primitive(),
+            PrimitiveArray::from_iter([1i32, 5])
         );
     }
 
@@ -189,13 +190,13 @@ mod tests {
         .unwrap();
         let filtered_run_end = filtered.as_::<RunEndVTable>();
 
-        assert_eq!(
-            filtered_run_end.ends().to_primitive().as_slice::<u8>(),
-            [1, 2, 3]
+        assert_arrays_eq!(
+            filtered_run_end.ends().to_primitive(),
+            PrimitiveArray::from_iter([1u8, 2, 3])
         );
-        assert_eq!(
-            filtered_run_end.values().to_primitive().as_slice::<i32>(),
-            [1, 4, 2]
+        assert_arrays_eq!(
+            filtered_run_end.values().to_primitive(),
+            PrimitiveArray::from_iter([1i32, 4, 2])
         );
     }
 }
diff --git a/encodings/sequence/src/array.rs b/encodings/sequence/src/array.rs
index 3b544d01c7c..cdc04f060ad 100644
--- a/encodings/sequence/src/array.rs
+++ b/encodings/sequence/src/array.rs
@@ -447,8 +447,8 @@ impl EncodeVTable<SequenceVTable> for SequenceVTable {
 
 #[cfg(test)]
 mod tests {
-    use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::assert_arrays_eq;
     use vortex_dtype::Nullability;
     use vortex_scalar::Scalar;
     use vortex_scalar::ScalarValue;
@@ -461,10 +461,7 @@ mod tests {
 
         let canon = PrimitiveArray::from_iter((0..4).map(|i| 2i64 + i * 3));
 
-        assert_eq!(
-            arr.to_primitive().as_slice::<i64>(),
-            canon.as_slice::<i64>()
-        )
+        assert_arrays_eq!(arr, canon);
     }
 
     #[test]
@@ -475,10 +472,7 @@ mod tests {
 
         let canon = PrimitiveArray::from_iter((2..3).map(|i| 2i64 + i * 3));
 
-        assert_eq!(
-            arr.to_primitive().as_slice::<i64>(),
-            canon.as_slice::<i64>()
-        )
+        assert_arrays_eq!(arr, canon);
     }
 
     #[test]
diff --git a/encodings/sparse/src/compute/mod.rs b/encodings/sparse/src/compute/mod.rs
index b5454c6f11c..7a806080ea2 100644
--- a/encodings/sparse/src/compute/mod.rs
+++ b/encodings/sparse/src/compute/mod.rs
@@ -82,7 +82,6 @@ mod test {
         let filtered_array = filtered_array.as_::<SparseVTable>();
 
         assert_eq!(filtered_array.len(), 1);
-        assert_eq!(filtered_array.patches().values().len(), 1);
         assert_arrays_eq!(
             filtered_array.patches().indices(),
             PrimitiveArray::from_iter([0u64])
@@ -104,7 +103,6 @@ mod test {
         let filtered_array = filter(&array, &mask).unwrap();
         let filtered_array = filtered_array.as_::<SparseVTable>();
 
-        assert_eq!(filtered_array.len(), 4);
         assert_arrays_eq!(
             filtered_array.patches().indices(),
             PrimitiveArray::from_iter([1u64, 3])
diff --git a/encodings/sparse/src/compute/take.rs b/encodings/sparse/src/compute/take.rs
index 9a9a553619b..6765af028b5 100644
--- a/encodings/sparse/src/compute/take.rs
+++ b/encodings/sparse/src/compute/take.rs
@@ -121,13 +121,13 @@ mod test {
         let taken_arr = take(&sparse, &buffer![69, 37].into_array()).unwrap();
         let taken = taken_arr.as_::<SparseVTable>();
 
-        assert_eq!(
-            taken.patches().indices().to_primitive().as_slice::<u64>(),
-            [1]
+        assert_arrays_eq!(
+            taken.patches().indices().to_primitive(),
+            PrimitiveArray::from_iter([1u64])
         );
-        assert_eq!(
-            taken.patches().values().to_primitive().as_slice::<f64>(),
-            [0.47f64]
+        assert_arrays_eq!(
+            taken.patches().values().to_primitive(),
+            PrimitiveArray::from_option_iter([Some(0.47f64)])
         );
         assert_eq!(taken.len(), 2);
     }
diff --git a/encodings/zigzag/src/compress.rs b/encodings/zigzag/src/compress.rs
index d3a30a557ea..a3828888c4c 100644
--- a/encodings/zigzag/src/compress.rs
+++ b/encodings/zigzag/src/compress.rs
@@ -72,6 +72,7 @@ where
 #[cfg(test)]
 mod test {
     use vortex_array::ToCanonical;
+    use vortex_array::assert_arrays_eq;
 
     use super::*;
     use crate::ZigZagVTable;
@@ -80,36 +81,36 @@ mod test {
     fn test_compress_i8() {
         let compressed = zigzag_encode(PrimitiveArray::from_iter(-100_i8..100)).unwrap();
         assert!(compressed.is::<ZigZagVTable>());
-        assert_eq!(
-            compressed.to_primitive().as_slice::<i8>(),
-            (-100_i8..100).collect::<Vec<_>>()
+        assert_arrays_eq!(
+            compressed.to_primitive(),
+            PrimitiveArray::from_iter(-100_i8..100)
         );
     }
     #[test]
     fn test_compress_i16() {
         let compressed = zigzag_encode(PrimitiveArray::from_iter(-100_i16..100)).unwrap();
         assert!(compressed.is::<ZigZagVTable>());
-        assert_eq!(
-            compressed.to_primitive().as_slice::<i16>(),
-            (-100_i16..100).collect::<Vec<_>>()
+        assert_arrays_eq!(
+            compressed.to_primitive(),
+            PrimitiveArray::from_iter(-100_i16..100)
         );
     }
     #[test]
     fn test_compress_i32() {
         let compressed = zigzag_encode(PrimitiveArray::from_iter(-100_i32..100)).unwrap();
         assert!(compressed.is::<ZigZagVTable>());
-        assert_eq!(
-            compressed.to_primitive().as_slice::<i32>(),
-            (-100_i32..100).collect::<Vec<_>>()
+        assert_arrays_eq!(
+            compressed.to_primitive(),
+            PrimitiveArray::from_iter(-100_i32..100)
         );
     }
     #[test]
     fn test_compress_i64() {
         let compressed = zigzag_encode(PrimitiveArray::from_iter(-100_i64..100)).unwrap();
         assert!(compressed.is::<ZigZagVTable>());
-        assert_eq!(
-            compressed.to_primitive().as_slice::<i64>(),
-            (-100_i64..100).collect::<Vec<_>>()
+        assert_arrays_eq!(
+            compressed.to_primitive(),
+            PrimitiveArray::from_iter(-100_i64..100)
         );
     }
 }
diff --git a/encodings/zigzag/src/compute/cast.rs b/encodings/zigzag/src/compute/cast.rs
index 15c6040507f..b6d9a830dcb 100644
--- a/encodings/zigzag/src/compute/cast.rs
+++ b/encodings/zigzag/src/compute/cast.rs
@@ -32,7 +32,6 @@ register_kernel!(CastKernelAdapter(ZigZagVTable).lift());
 mod tests {
     use rstest::rstest;
     use vortex_array::Array;
-    use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::compute::cast;
@@ -67,8 +66,7 @@ mod tests {
             "Cast should preserve ZigZag encoding"
         );
 
-        let decoded = casted.to_primitive();
-        assert_arrays_eq!(decoded, PrimitiveArray::from_iter([-100i64, -1, 0, 1, 100]));
+        assert_arrays_eq!(casted, PrimitiveArray::from_iter([-100i64, -1, 0, 1, 100]));
     }
 
     #[test]
@@ -88,9 +86,8 @@ mod tests {
             "Should remain ZigZag encoded"
         );
 
-        let decoded = casted.to_primitive();
         assert_arrays_eq!(
-            decoded,
+            casted,
             PrimitiveArray::from_iter([100i16, -50, 0, 25, -100])
         );
 
@@ -109,9 +106,8 @@ mod tests {
             "Should remain ZigZag encoded"
         );
 
-        let decoded64 = casted64.to_primitive();
         assert_arrays_eq!(
-            decoded64,
+            casted64,
             PrimitiveArray::from_iter([1000i64, -500, 0, 250, -1000])
         );
     }
diff --git a/encodings/zigzag/src/compute/mod.rs b/encodings/zigzag/src/compute/mod.rs
index 56f2c81f3b4..e7b33551bbb 100644
--- a/encodings/zigzag/src/compute/mod.rs
+++ b/encodings/zigzag/src/compute/mod.rs
@@ -75,7 +75,6 @@ mod tests {
     use vortex_array::Array;
     use vortex_array::ArrayRef;
     use vortex_array::IntoArray;
-    use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::compute::conformance::binary_numeric::test_binary_numeric_array;
@@ -118,13 +117,12 @@ mod tests {
             .unwrap();
 
         let indices = buffer![0, 2].into_array();
-        let actual = take(&zigzag, &indices).unwrap().to_primitive();
+        let actual = take(&zigzag, &indices).unwrap();
         let expected = ZigZagVTable
             .as_vtable()
             .encode(&buffer![-189, 1].into_array().to_canonical(), None)
             .unwrap()
-            .unwrap()
-            .to_primitive();
+            .unwrap();
         assert_arrays_eq!(actual, expected);
     }
 
@@ -136,13 +134,12 @@ mod tests {
             .unwrap()
             .unwrap();
         let filter_mask = BitBuffer::from(vec![true, false, true]).into();
-        let actual = filter(&zigzag, &filter_mask).unwrap().to_primitive();
+        let actual = filter(&zigzag, &filter_mask).unwrap();
         let expected = ZigZagVTable
             .as_vtable()
             .encode(&buffer![-189, 1].into_array().to_canonical(), None)
             .unwrap()
-            .unwrap()
-            .to_primitive();
+            .unwrap();
         assert_arrays_eq!(actual, expected);
     }
 
diff --git a/encodings/zstd/src/compute/cast.rs b/encodings/zstd/src/compute/cast.rs
index b51b6658062..d4ad7cfc66a 100644
--- a/encodings/zstd/src/compute/cast.rs
+++ b/encodings/zstd/src/compute/cast.rs
@@ -148,8 +148,7 @@ mod tests {
         );
         // Verify the values are correct
         let decoded = casted.to_primitive();
-        let u32_values = decoded.as_slice::<u32>();
-        assert_eq!(u32_values, &[20, 30, 40, 50]);
+        assert_arrays_eq!(decoded, PrimitiveArray::from_iter([20u32, 30, 40, 50]));
     }
 
     #[test]
diff --git a/encodings/zstd/src/test.rs b/encodings/zstd/src/test.rs
index 83d7c80f60e..250b336c61b 100644
--- a/encodings/zstd/src/test.rs
+++ b/encodings/zstd/src/test.rs
@@ -34,7 +34,7 @@ fn test_zstd_compress_decompress() {
     assert!(compressed.dictionary.is_none());
 
     // check full decompression works
-    let decompressed = compressed.decompress().to_primitive();
+    let decompressed = compressed.decompress();
     assert_arrays_eq!(decompressed, PrimitiveArray::from_iter(data));
 
     // check slicing works
@@ -42,15 +42,10 @@ fn test_zstd_compress_decompress() {
     for i in 0_i32..5 {
         assert_nth_scalar!(slice, i as usize, 100 + i);
     }
-    let primitive = slice.to_primitive();
-    assert_arrays_eq!(
-        primitive,
-        PrimitiveArray::from_iter([100, 101, 102, 103, 104])
-    );
+    assert_arrays_eq!(slice, PrimitiveArray::from_iter([100, 101, 102, 103, 104]));
 
     let slice = compressed.slice(200..200);
-    let primitive = slice.to_primitive();
-    assert_arrays_eq!(primitive, PrimitiveArray::from_iter(Vec::<i32>::new()));
+    assert_arrays_eq!(slice, PrimitiveArray::from_iter(Vec::<i32>::new()));
 }
 
 #[test]
@@ -63,8 +58,7 @@ fn test_zstd_empty() {
 
     let compressed = ZstdArray::from_primitive(&array, 3, 100).unwrap();
 
-    let primitive = compressed.to_primitive();
-    assert_arrays_eq!(primitive, PrimitiveArray::from_iter(data));
+    assert_arrays_eq!(compressed, PrimitiveArray::from_iter(data));
 }
 
 #[test]
diff --git a/vortex-array/src/arrays/chunked/compute/take.rs b/vortex-array/src/arrays/chunked/compute/take.rs
index 71c0e3a4458..009d7bad300 100644
--- a/vortex-array/src/arrays/chunked/compute/take.rs
+++ b/vortex-array/src/arrays/chunked/compute/take.rs
@@ -98,7 +98,7 @@ mod test {
     use crate::arrays::PrimitiveArray;
     use crate::arrays::StructArray;
     use crate::arrays::chunked::ChunkedArray;
-    use crate::canonical::ToCanonical;
+    use crate::assert_arrays_eq;
     use crate::compute::conformance::take::test_take_conformance;
     use crate::compute::take;
     use crate::validity::Validity;
@@ -112,8 +112,8 @@ mod test {
         assert_eq!(arr.len(), 9);
         let indices = buffer![0u64, 0, 6, 4].into_array();
 
-        let result = take(arr.as_ref(), indices.as_ref()).unwrap().to_primitive();
-        assert_eq!(result.as_slice::<i32>(), &[1, 1, 1, 2]);
+        let result = take(arr.as_ref(), indices.as_ref()).unwrap();
+        assert_arrays_eq!(result, PrimitiveArray::from_iter([1i32, 1, 1, 2]));
     }
 
     #[test]
@@ -137,10 +137,7 @@ mod test {
             Validity::Array(BoolArray::from_iter(vec![true, false, true]).to_array()),
         )
         .unwrap();
-        assert_eq!(result.dtype(), expect.dtype());
-        assert_eq!(result.scalar_at(0), expect.scalar_at(0));
-        assert_eq!(result.scalar_at(1), expect.scalar_at(1));
-        assert_eq!(result.scalar_at(2), expect.scalar_at(2));
+        assert_arrays_eq!(result, expect);
     }
 
     #[test]
@@ -152,11 +149,14 @@ mod test {
         assert_eq!(arr.len(), 9);
 
         let indices = PrimitiveArray::empty::<u64>(Nullability::NonNullable);
-        let result = take(arr.as_ref(), indices.as_ref()).unwrap().to_primitive();
+        let result = take(arr.as_ref(), indices.as_ref()).unwrap();
 
         assert!(result.is_empty());
         assert_eq!(result.dtype(), arr.dtype());
-        assert!(result.as_slice::<i32>().is_empty());
+        assert_arrays_eq!(
+            result,
+            PrimitiveArray::empty::<i32>(Nullability::NonNullable)
+        );
     }
 
     #[test]
diff --git a/vortex-array/src/arrays/chunked/tests.rs b/vortex-array/src/arrays/chunked/tests.rs
index aa7dcba56ed..1b7957c5e98 100644
--- a/vortex-array/src/arrays/chunked/tests.rs
+++ b/vortex-array/src/arrays/chunked/tests.rs
@@ -6,19 +6,18 @@ use std::sync::Arc;
 use vortex_buffer::Buffer;
 use vortex_buffer::buffer;
 use vortex_dtype::DType;
-use vortex_dtype::NativePType;
 use vortex_dtype::Nullability;
 use vortex_dtype::PType;
 use vortex_dtype::PType::I32;
 
 use crate::IntoArray;
 use crate::accessor::ArrayAccessor;
-use crate::array::Array;
 use crate::arrays::ChunkedArray;
-use crate::arrays::ChunkedVTable;
 use crate::arrays::ListArray;
+use crate::arrays::PrimitiveArray;
 use crate::arrays::StructArray;
 use crate::arrays::VarBinViewArray;
+use crate::assert_arrays_eq;
 use crate::canonical::ToCanonical;
 use crate::validity::Validity;
 
@@ -34,47 +33,52 @@ fn chunked_array() -> ChunkedArray {
     .unwrap()
 }
 
-fn assert_equal_slices<T: NativePType>(arr: &dyn Array, slice: &[T]) {
-    let mut values = Vec::with_capacity(arr.len());
-    if let Some(arr) = arr.as_opt::<ChunkedVTable>() {
-        arr.chunks()
-            .iter()
-            .map(|a| a.to_primitive())
-            .for_each(|a| values.extend_from_slice(a.as_slice::<T>()));
-    } else {
-        values.extend_from_slice(arr.to_primitive().as_slice::<T>());
-    }
-    assert_eq!(values, slice);
-}
-
 #[test]
 fn slice_middle() {
-    assert_equal_slices(&chunked_array().slice(2..5), &[3u64, 4, 5])
+    assert_arrays_eq!(
+        chunked_array().slice(2..5),
+        PrimitiveArray::from_iter([3u64, 4, 5])
+    );
 }
 
 #[test]
 fn slice_begin() {
-    assert_equal_slices(&chunked_array().slice(1..3), &[2u64, 3]);
+    assert_arrays_eq!(
+        chunked_array().slice(1..3),
+        PrimitiveArray::from_iter([2u64, 3])
+    );
 }
 
 #[test]
 fn slice_aligned() {
-    assert_equal_slices(&chunked_array().slice(3..6), &[4u64, 5, 6]);
+    assert_arrays_eq!(
+        chunked_array().slice(3..6),
+        PrimitiveArray::from_iter([4u64, 5, 6])
+    );
 }
 
 #[test]
 fn slice_many_aligned() {
-    assert_equal_slices(&chunked_array().slice(0..6), &[1u64, 2, 3, 4, 5, 6]);
+    assert_arrays_eq!(
+        chunked_array().slice(0..6),
+        PrimitiveArray::from_iter([1u64, 2, 3, 4, 5, 6])
+    );
 }
 
 #[test]
 fn slice_end() {
-    assert_equal_slices(&chunked_array().slice(7..8), &[8u64]);
+    assert_arrays_eq!(
+        chunked_array().slice(7..8),
+        PrimitiveArray::from_iter([8u64])
+    );
 }
 
 #[test]
 fn slice_exactly_end() {
-    assert_equal_slices(&chunked_array().slice(6..9), &[7u64, 8, 9]);
+    assert_arrays_eq!(
+        chunked_array().slice(6..9),
+        PrimitiveArray::from_iter([7u64, 8, 9])
+    );
 }
 
 #[test]
diff --git a/vortex-array/src/arrays/constant/compute/take.rs b/vortex-array/src/arrays/constant/compute/take.rs
index 4dd83f164d8..4e90863b0ed 100644
--- a/vortex-array/src/arrays/constant/compute/take.rs
+++ b/vortex-array/src/arrays/constant/compute/take.rs
@@ -66,6 +66,7 @@ mod tests {
     use crate::ToCanonical;
     use crate::arrays::ConstantArray;
     use crate::arrays::PrimitiveArray;
+    use crate::assert_arrays_eq;
     use crate::compute::conformance::take::test_take_conformance;
     use crate::compute::take;
     use crate::validity::Validity;
@@ -87,7 +88,13 @@ mod tests {
             &array.dtype().with_nullability(Nullability::Nullable),
             taken.dtype()
         );
-        assert_eq!(taken.to_primitive().as_slice::<i32>(), &[42, 42, 42]);
+        assert_arrays_eq!(
+            taken.to_primitive(),
+            PrimitiveArray::new(
+                buffer![42i32, 42, 42],
+                Validity::from_iter([false, true, false])
+            )
+        );
         assert_eq!(taken.validity_mask().indices(), AllOr::Some(valid_indices));
     }
 
@@ -103,7 +110,10 @@ mod tests {
             &array.dtype().with_nullability(Nullability::Nullable),
             taken.dtype()
         );
-        assert_eq!(taken.to_primitive().as_slice::<i32>(), &[42, 42, 42]);
+        assert_arrays_eq!(
+            taken.to_primitive(),
+            PrimitiveArray::new(buffer![42i32, 42, 42], Validity::AllValid)
+        );
         assert_eq!(taken.validity_mask().indices(), AllOr::All);
     }
 
diff --git a/vortex-array/src/arrays/constant/vtable/canonical.rs b/vortex-array/src/arrays/constant/vtable/canonical.rs
index dcdf18c4ed3..341f034c6e9 100644
--- a/vortex-array/src/arrays/constant/vtable/canonical.rs
+++ b/vortex-array/src/arrays/constant/vtable/canonical.rs
@@ -335,6 +335,8 @@ mod tests {
     use crate::IntoArray;
     use crate::arrays::ConstantArray;
     use crate::arrays::ListViewRebuildMode;
+    use crate::arrays::PrimitiveArray;
+    use crate::assert_arrays_eq;
     use crate::canonical::ToCanonical;
     use crate::expr::stats::Stat;
     use crate::expr::stats::StatsProvider;
@@ -411,17 +413,17 @@ mod tests {
         let const_array = ConstantArray::new(list_scalar, 2).into_array();
         let canonical_const = const_array.to_listview();
         let list_array = canonical_const.rebuild(ListViewRebuildMode::MakeZeroCopyToList);
-        assert_eq!(
-            list_array.elements().to_primitive().as_slice::<u64>(),
-            [1u64, 2, 1, 2]
+        assert_arrays_eq!(
+            list_array.elements().to_primitive(),
+            PrimitiveArray::from_iter([1u64, 2, 1, 2])
         );
-        assert_eq!(
-            list_array.offsets().to_primitive().as_slice::<u64>(),
-            [0u64, 2]
+        assert_arrays_eq!(
+            list_array.offsets().to_primitive(),
+            PrimitiveArray::from_iter([0u64, 2])
         );
-        assert_eq!(
-            list_array.sizes().to_primitive().as_slice::<u64>(),
-            [2u64, 2]
+        assert_arrays_eq!(
+            list_array.sizes().to_primitive(),
+            PrimitiveArray::from_iter([2u64, 2])
         );
     }
 
@@ -435,13 +437,13 @@ mod tests {
         let const_array = ConstantArray::new(list_scalar, 2).into_array();
         let canonical_const = const_array.to_listview();
         assert!(canonical_const.elements().to_primitive().is_empty());
-        assert_eq!(
-            canonical_const.offsets().to_primitive().as_slice::<u64>(),
-            [0u64, 0]
+        assert_arrays_eq!(
+            canonical_const.offsets().to_primitive(),
+            PrimitiveArray::from_iter([0u64, 0])
         );
-        assert_eq!(
-            canonical_const.sizes().to_primitive().as_slice::<u64>(),
-            [0u64, 0]
+        assert_arrays_eq!(
+            canonical_const.sizes().to_primitive(),
+            PrimitiveArray::from_iter([0u64, 0])
         );
     }
 
@@ -454,13 +456,13 @@ mod tests {
         let const_array = ConstantArray::new(list_scalar, 2).into_array();
         let canonical_const = const_array.to_listview();
         assert!(canonical_const.elements().to_primitive().is_empty());
-        assert_eq!(
-            canonical_const.offsets().to_primitive().as_slice::<u64>(),
-            [0u64, 0]
+        assert_arrays_eq!(
+            canonical_const.offsets().to_primitive(),
+            PrimitiveArray::from_iter([0u64, 0])
         );
-        assert_eq!(
-            canonical_const.sizes().to_primitive().as_slice::<u64>(),
-            [0u64, 0]
+        assert_arrays_eq!(
+            canonical_const.sizes().to_primitive(),
+            PrimitiveArray::from_iter([0u64, 0])
         );
     }
 
@@ -513,7 +515,7 @@ mod tests {
         for i in 0..4 {
             let list = canonical.fixed_size_list_elements_at(i);
             let list_primitive = list.to_primitive();
-            assert_eq!(list_primitive.as_slice::<i32>(), [10, 20, 30]);
+            assert_arrays_eq!(list_primitive, PrimitiveArray::from_iter([10i32, 20, 30]));
         }
     }
 
@@ -538,7 +540,10 @@ mod tests {
 
         // Check elements.
         let elements = canonical.elements().to_primitive();
-        assert_eq!(elements.as_slice::<f64>(), [1.5, 2.5, 1.5, 2.5, 1.5, 2.5]);
+        assert_arrays_eq!(
+            elements,
+            PrimitiveArray::from_iter([1.5f64, 2.5, 1.5, 2.5, 1.5, 2.5])
+        );
     }
 
     #[test]
@@ -622,7 +627,7 @@ mod tests {
         assert_eq!(canonical.list_size(), 1);
 
         let elements = canonical.elements().to_primitive();
-        assert_eq!(elements.as_slice::<i16>(), [42]);
+        assert_arrays_eq!(elements, PrimitiveArray::from_iter([42i16]));
     }
 
     #[test]
@@ -647,9 +652,12 @@ mod tests {
 
         // Check elements including nulls.
         let elements = canonical.elements().to_primitive();
-        assert_eq!(elements.as_slice::<i32>()[0], 100);
-        assert_eq!(elements.as_slice::<i32>()[1], 0); // null becomes 0
-        assert_eq!(elements.as_slice::<i32>()[2], 200);
+        assert_eq!(elements.scalar_at(0), Scalar::from(100i32));
+        assert_eq!(
+            elements.scalar_at(1),
+            Scalar::null(DType::Primitive(PType::I32, Nullability::Nullable))
+        );
+        assert_eq!(elements.scalar_at(2), Scalar::from(200i32));
 
         // Check element validity.
         let element_validity = elements.validity();
@@ -690,11 +698,11 @@ mod tests {
         // Check pattern repeats correctly.
         for i in 0..1000 {
             let base = i * 5;
-            assert_eq!(elements.as_slice::<u8>()[base], 1);
-            assert_eq!(elements.as_slice::<u8>()[base + 1], 2);
-            assert_eq!(elements.as_slice::<u8>()[base + 2], 3);
-            assert_eq!(elements.as_slice::<u8>()[base + 3], 4);
-            assert_eq!(elements.as_slice::<u8>()[base + 4], 5);
+            assert_eq!(elements.scalar_at(base), Scalar::from(1u8));
+            assert_eq!(elements.scalar_at(base + 1), Scalar::from(2u8));
+            assert_eq!(elements.scalar_at(base + 2), Scalar::from(3u8));
+            assert_eq!(elements.scalar_at(base + 3), Scalar::from(4u8));
+            assert_eq!(elements.scalar_at(base + 4), Scalar::from(5u8));
         }
     }
 }
diff --git a/vortex-array/src/arrays/datetime/test.rs b/vortex-array/src/arrays/datetime/test.rs
index 6b710ad52ca..fbbe387821f 100644
--- a/vortex-array/src/arrays/datetime/test.rs
+++ b/vortex-array/src/arrays/datetime/test.rs
@@ -11,6 +11,7 @@ use crate::ToCanonical;
 use crate::array::Array;
 use crate::arrays::PrimitiveArray;
 use crate::arrays::TemporalArray;
+use crate::assert_arrays_eq;
 use crate::validity::Validity;
 use crate::vtable::ValidityHelper;
 
@@ -18,9 +19,11 @@ macro_rules! test_temporal_roundtrip {
     ($prim:ty, $constructor:expr, $unit:expr) => {{
         let array = buffer![100 as $prim].into_array();
         let temporal: TemporalArray = $constructor(array, $unit);
-        let prims = temporal.temporal_values().to_primitive();
 
-        assert_eq!(prims.as_slice::<$prim>(), vec![100 as $prim].as_slice(),);
+        assert_arrays_eq!(
+            temporal.temporal_values(),
+            PrimitiveArray::from_iter([100 as $prim])
+        );
         assert_eq!(temporal.temporal_metadata().time_unit(), $unit);
     }};
 }
@@ -146,8 +149,10 @@ fn test_timestamp() {
             let temporal_array =
                 TemporalArray::new_timestamp(ts_array.to_array(), unit, tz.clone());
 
-            let values = temporal_array.temporal_values().to_primitive();
-            assert_eq!(values.as_slice::<i64>(), vec![100i64].as_slice());
+            assert_arrays_eq!(
+                temporal_array.temporal_values(),
+                PrimitiveArray::from_iter([100i64])
+            );
             assert_eq!(
                 temporal_array.temporal_metadata(),
                 &TemporalMetadata::Timestamp(unit, tz)
diff --git a/vortex-array/src/arrays/listview/rebuild.rs b/vortex-array/src/arrays/listview/rebuild.rs
index 2904fec1fcd..e84547f835e 100644
--- a/vortex-array/src/arrays/listview/rebuild.rs
+++ b/vortex-array/src/arrays/listview/rebuild.rs
@@ -266,6 +266,7 @@ mod tests {
     use crate::ToCanonical;
     use crate::arrays::ListViewArray;
     use crate::arrays::PrimitiveArray;
+    use crate::assert_arrays_eq;
     use crate::validity::Validity;
     use crate::vtable::ValidityHelper;
 
@@ -293,11 +294,15 @@ mod tests {
         assert_eq!(flattened.size_at(1), 2);
 
         // Verify the data is correct
-        let list0 = flattened.list_elements_at(0).to_primitive();
-        assert_eq!(list0.as_slice::<i32>(), &[1, 2, 3]);
+        assert_arrays_eq!(
+            flattened.list_elements_at(0),
+            PrimitiveArray::from_iter([1i32, 2, 3])
+        );
 
-        let list1 = flattened.list_elements_at(1).to_primitive();
-        assert_eq!(list1.as_slice::<i32>(), &[2, 3]);
+        assert_arrays_eq!(
+            flattened.list_elements_at(1),
+            PrimitiveArray::from_iter([2i32, 3])
+        );
     }
 
     #[test]
@@ -327,11 +332,15 @@ mod tests {
         assert!(flattened.validity().is_valid(2));
 
         // Verify valid lists contain correct data
-        let list0 = flattened.list_elements_at(0).to_primitive();
-        assert_eq!(list0.as_slice::<i32>(), &[1, 2]);
+        assert_arrays_eq!(
+            flattened.list_elements_at(0),
+            PrimitiveArray::from_iter([1i32, 2])
+        );
 
-        let list2 = flattened.list_elements_at(2).to_primitive();
-        assert_eq!(list2.as_slice::<i32>(), &[3]);
+        assert_arrays_eq!(
+            flattened.list_elements_at(2),
+            PrimitiveArray::from_iter([3i32])
+        );
     }
 
     #[test]
@@ -362,11 +371,15 @@ mod tests {
         assert_eq!(trimmed.size_at(1), 2);
 
         // Verify the data is correct.
-        let list0 = trimmed.list_elements_at(0).to_primitive();
-        assert_eq!(list0.as_slice::<i32>(), &[1, 2]);
+        assert_arrays_eq!(
+            trimmed.list_elements_at(0),
+            PrimitiveArray::from_iter([1i32, 2])
+        );
 
-        let list1 = trimmed.list_elements_at(1).to_primitive();
-        assert_eq!(list1.as_slice::<i32>(), &[3, 4]);
+        assert_arrays_eq!(
+            trimmed.list_elements_at(1),
+            PrimitiveArray::from_iter([3i32, 4])
+        );
 
         // Note that element at index 2 (97) is preserved as a gap.
         let all_elements = trimmed.elements().to_primitive();
@@ -415,10 +428,14 @@ mod tests {
         assert!(!exact.is_valid(3));
 
         // Verify data is preserved
-        let list0 = exact.list_elements_at(0).to_primitive();
-        assert_eq!(list0.as_slice::<i32>(), &[1, 2]);
+        assert_arrays_eq!(
+            exact.list_elements_at(0),
+            PrimitiveArray::from_iter([1i32, 2])
+        );
 
-        let list1 = exact.list_elements_at(1).to_primitive();
-        assert_eq!(list1.as_slice::<i32>(), &[3, 4]);
+        assert_arrays_eq!(
+            exact.list_elements_at(1),
+            PrimitiveArray::from_iter([3i32, 4])
+        );
     }
 }
diff --git a/vortex-array/src/arrays/listview/tests/filter.rs b/vortex-array/src/arrays/listview/tests/filter.rs
index ce3be49dce0..10aa14853b0 100644
--- a/vortex-array/src/arrays/listview/tests/filter.rs
+++ b/vortex-array/src/arrays/listview/tests/filter.rs
@@ -15,6 +15,7 @@ use crate::ToCanonical;
 use crate::arrays::ConstantArray;
 use crate::arrays::ListViewArray;
 use crate::arrays::PrimitiveArray;
+use crate::assert_arrays_eq;
 use crate::compute::conformance::filter::test_filter_conformance;
 use crate::compute::filter;
 use crate::validity::Validity;
@@ -52,11 +53,9 @@ fn test_filter_preserves_unreferenced_elements() {
     assert_eq!(result_list.len(), 2, "Wrong number of filtered lists");
 
     // Verify the entire elements array is preserved.
-    let result_elements = result_list.elements().to_primitive();
-    assert_eq!(
-        result_elements.as_slice::<i32>(),
-        &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
-        "Elements array should be preserved"
+    assert_arrays_eq!(
+        result_list.elements(),
+        PrimitiveArray::from_iter([0i32, 1, 2, 3, 4, 5, 6, 7, 8, 9])
     );
 
     // Verify offsets are unchanged.
@@ -86,10 +85,9 @@ fn test_filter_with_gaps() {
     assert_eq!(result_list.len(), 3, "Wrong filter result length");
 
     // Verify the entire elements array is preserved including gaps.
-    let result_elements = result_list.elements().to_primitive();
-    assert_eq!(
-        result_elements.as_slice::<i32>(),
-        &[1, 2, 3, 999, 999, 999, 7, 8, 9, 999, 11, 12]
+    assert_arrays_eq!(
+        result_list.elements(),
+        PrimitiveArray::from_iter([1i32, 2, 3, 999, 999, 999, 7, 8, 9, 999, 11, 12])
     );
 
     // Verify offsets are unchanged.
diff --git a/vortex-array/src/arrays/listview/tests/take.rs b/vortex-array/src/arrays/listview/tests/take.rs
index f0580423985..7de5812a3d2 100644
--- a/vortex-array/src/arrays/listview/tests/take.rs
+++ b/vortex-array/src/arrays/listview/tests/take.rs
@@ -15,6 +15,7 @@ use crate::ToCanonical;
 use crate::arrays::ConstantArray;
 use crate::arrays::ListViewArray;
 use crate::arrays::PrimitiveArray;
+use crate::assert_arrays_eq;
 use crate::compute::conformance::take::test_take_conformance;
 use crate::compute::take;
 use crate::validity::Validity;
@@ -52,10 +53,9 @@ fn test_take_preserves_unreferenced_elements() {
     assert_eq!(result_list.len(), 2);
 
     // Verify the entire elements array is preserved.
-    let result_elements = result_list.elements().to_primitive();
-    assert_eq!(
-        result_elements.as_slice::<i32>(),
-        &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    assert_arrays_eq!(
+        result_list.elements(),
+        PrimitiveArray::from_iter([0i32, 1, 2, 3, 4, 5, 6, 7, 8, 9])
     );
 
     // Verify offsets are preserved.
@@ -80,10 +80,9 @@ fn test_take_with_gaps() {
     let result_list = result.to_listview();
 
     // Verify the entire elements array is preserved including gaps.
-    let result_elements = result_list.elements().to_primitive();
-    assert_eq!(
-        result_elements.as_slice::<i32>(),
-        &[1, 2, 3, 999, 999, 999, 7, 8, 9, 999, 11, 12]
+    assert_arrays_eq!(
+        result_list.elements(),
+        PrimitiveArray::from_iter([1i32, 2, 3, 999, 999, 999, 7, 8, 9, 999, 11, 12])
     );
 
     // Verify the lists still read correctly despite gaps.
diff --git a/vortex-array/src/arrays/primitive/array/patch.rs b/vortex-array/src/arrays/primitive/array/patch.rs
index c497ac3936b..7967fb20b7a 100644
--- a/vortex-array/src/arrays/primitive/array/patch.rs
+++ b/vortex-array/src/arrays/primitive/array/patch.rs
@@ -130,12 +130,16 @@ mod tests {
 
     use super::*;
     use crate::ToCanonical;
+    use crate::assert_arrays_eq;
     use crate::validity::Validity;
 
     #[test]
     fn patch_sliced() {
         let input = PrimitiveArray::new(buffer![2u32; 10], Validity::AllValid);
         let sliced = input.slice(2..8);
-        assert_eq!(sliced.to_primitive().as_slice::<u32>(), &[2u32; 6]);
+        assert_arrays_eq!(
+            sliced.to_primitive(),
+            PrimitiveArray::new(buffer![2u32; 6], Validity::AllValid)
+        );
     }
 }
diff --git a/vortex-array/src/arrays/primitive/compute/cast.rs b/vortex-array/src/arrays/primitive/compute/cast.rs
index 68927d4060f..cd2f82446e6 100644
--- a/vortex-array/src/arrays/primitive/compute/cast.rs
+++ b/vortex-array/src/arrays/primitive/compute/cast.rs
@@ -106,6 +106,7 @@ mod test {
 
     use crate::IntoArray;
     use crate::arrays::PrimitiveArray;
+    use crate::assert_arrays_eq;
     use crate::canonical::ToCanonical;
     use crate::compute::cast;
     use crate::compute::conformance::cast::test_cast_conformance;
@@ -118,7 +119,7 @@ mod test {
 
         // cast from u32 to u8
         let p = cast(&arr, PType::U8.into()).unwrap().to_primitive();
-        assert_eq!(p.as_slice::<u8>(), vec![0u8, 10, 200]);
+        assert_arrays_eq!(p, PrimitiveArray::from_iter([0u8, 10, 200]));
         assert_eq!(p.validity(), &Validity::NonNullable);
 
         // to nullable
@@ -128,7 +129,10 @@ mod test {
         )
         .unwrap()
         .to_primitive();
-        assert_eq!(p.as_slice::<u8>(), vec![0u8, 10, 200]);
+        assert_arrays_eq!(
+            p,
+            PrimitiveArray::new(buffer![0u8, 10, 200], Validity::AllValid)
+        );
         assert_eq!(p.validity(), &Validity::AllValid);
 
         // back to non-nullable
@@ -138,7 +142,7 @@ mod test {
         )
         .unwrap()
         .to_primitive();
-        assert_eq!(p.as_slice::<u8>(), vec![0u8, 10, 200]);
+        assert_arrays_eq!(p, PrimitiveArray::from_iter([0u8, 10, 200]));
         assert_eq!(p.validity(), &Validity::NonNullable);
 
         // to nullable u32
@@ -148,7 +152,10 @@ mod test {
         )
         .unwrap()
         .to_primitive();
-        assert_eq!(p.as_slice::<u32>(), vec![0u32, 10, 200]);
+        assert_arrays_eq!(
+            p,
+            PrimitiveArray::new(buffer![0u32, 10, 200], Validity::AllValid)
+        );
         assert_eq!(p.validity(), &Validity::AllValid);
 
         // to non-nullable u8
@@ -158,7 +165,7 @@ mod test {
         )
         .unwrap()
         .to_primitive();
-        assert_eq!(p.as_slice::<u8>(), vec![0u8, 10, 200]);
+        assert_arrays_eq!(p, PrimitiveArray::from_iter([0u8, 10, 200]));
         assert_eq!(p.validity(), &Validity::NonNullable);
     }
 
@@ -166,7 +173,7 @@ mod test {
     fn cast_u32_f32() {
         let arr = buffer![0u32, 10, 200].into_array();
         let u8arr = cast(&arr, PType::F32.into()).unwrap().to_primitive();
-        assert_eq!(u8arr.as_slice::<f32>(), vec![0.0f32, 10., 200.]);
+        assert_arrays_eq!(u8arr, PrimitiveArray::from_iter([0.0f32, 10., 200.]));
     }
 
     #[test]
@@ -204,7 +211,10 @@ mod test {
         )
         .unwrap()
         .to_primitive();
-        assert_eq!(p.as_slice::<u32>(), vec![0, 0, 10]);
+        assert_arrays_eq!(
+            p,
+            PrimitiveArray::from_option_iter([None, Some(0u32), Some(10)])
+        );
         assert_eq!(
             p.validity_mask(),
             Mask::from(BitBuffer::from(vec![false, true, true]))
diff --git a/vortex-array/src/arrays/primitive/compute/fill_null.rs b/vortex-array/src/arrays/primitive/compute/fill_null.rs
index 3036c69c153..4b23de81bcb 100644
--- a/vortex-array/src/arrays/primitive/compute/fill_null.rs
+++ b/vortex-array/src/arrays/primitive/compute/fill_null.rs
@@ -53,6 +53,7 @@ mod test {
     use crate::IntoArray;
     use crate::arrays::BoolArray;
     use crate::arrays::primitive::PrimitiveArray;
+    use crate::assert_arrays_eq;
     use crate::canonical::ToCanonical;
     use crate::compute::fill_null;
     use crate::validity::Validity;
@@ -63,7 +64,7 @@ mod test {
         let p = fill_null(arr.as_ref(), &Scalar::from(42u8))
             .unwrap()
             .to_primitive();
-        assert_eq!(p.as_slice::<u8>(), vec![42, 8, 42, 10, 42]);
+        assert_arrays_eq!(p, PrimitiveArray::from_iter([42u8, 8, 42, 10, 42]));
         assert!(p.validity_mask().all_true());
     }
 
@@ -74,7 +75,7 @@ mod test {
         let p = fill_null(arr.as_ref(), &Scalar::from(255u8))
             .unwrap()
             .to_primitive();
-        assert_eq!(p.as_slice::<u8>(), vec![255, 255, 255, 255, 255]);
+        assert_arrays_eq!(p, PrimitiveArray::from_iter([255u8, 255, 255, 255, 255]));
         assert!(p.validity_mask().all_true());
     }
 
@@ -87,7 +88,7 @@ mod test {
         let p = fill_null(arr.as_ref(), &Scalar::from(255u8))
             .unwrap()
             .to_primitive();
-        assert_eq!(p.as_slice::<u8>(), vec![8, 10, 12, 14, 16]);
+        assert_arrays_eq!(p, PrimitiveArray::from_iter([8u8, 10, 12, 14, 16]));
         assert!(p.validity_mask().all_true());
     }
 
@@ -97,7 +98,7 @@ mod test {
         let p = fill_null(&arr, &Scalar::from(255u8))
             .unwrap()
             .to_primitive();
-        assert_eq!(p.as_slice::<u8>(), vec![8u8, 10, 12, 14, 16]);
+        assert_arrays_eq!(p, PrimitiveArray::from_iter([8u8, 10, 12, 14, 16]));
         assert!(p.validity_mask().all_true());
     }
 }
diff --git a/vortex-array/src/arrays/struct_/tests.rs b/vortex-array/src/arrays/struct_/tests.rs
index d768adff136..e32e0bd3aa0 100644
--- a/vortex-array/src/arrays/struct_/tests.rs
+++ b/vortex-array/src/arrays/struct_/tests.rs
@@ -16,6 +16,7 @@ use crate::arrays::ConstantArray;
 use crate::arrays::primitive::PrimitiveArray;
 use crate::arrays::struct_::StructArray;
 use crate::arrays::varbin::VarBinArray;
+use crate::assert_arrays_eq;
 use crate::validity::Validity;
 
 #[test]
@@ -52,7 +53,7 @@ fn test_project() {
     );
 
     let prims = &struct_b.fields[1];
-    assert_eq!(prims.to_primitive().as_slice::<i64>(), [0i64, 1, 2, 3, 4]);
+    assert_arrays_eq!(prims, PrimitiveArray::from_iter([0i64, 1, 2, 3, 4]));
 }
 
 #[test]
@@ -73,7 +74,7 @@ fn test_remove_column() {
         removed.dtype(),
         &DType::Primitive(PType::I64, Nullability::NonNullable)
     );
-    assert_eq!(removed.to_primitive().as_slice::<i64>(), [0i64, 1, 2, 3, 4]);
+    assert_arrays_eq!(removed, PrimitiveArray::from_iter([0i64, 1, 2, 3, 4]));
 
     assert_eq!(struct_a.names(), &["ys"]);
     assert_eq!(struct_a.fields.len(), 1);
@@ -82,9 +83,9 @@ fn test_remove_column() {
         struct_a.fields[0].dtype(),
         &DType::Primitive(PType::U64, Nullability::NonNullable)
     );
-    assert_eq!(
-        struct_a.fields[0].to_primitive().as_slice::<u64>(),
-        [4u64, 5, 6, 7, 8]
+    assert_arrays_eq!(
+        struct_a.fields[0],
+        PrimitiveArray::from_iter([4u64, 5, 6, 7, 8])
     );
 
     let empty = struct_a.remove_column("non_existent");
@@ -113,24 +114,21 @@ fn test_duplicate_field_names() {
 
     // field_by_name should return the first field with the matching name
     let first_value_field = struct_array.field_by_name("value").unwrap();
-    assert_eq!(
-        first_value_field.to_primitive().as_slice::<i32>(),
-        [1i32, 2, 3] // This is field1, not field3
+    assert_arrays_eq!(
+        first_value_field,
+        PrimitiveArray::from_iter([1i32, 2, 3]) // This is field1, not field3
     );
 
     // Verify field_by_name_opt also returns the first match
     let opt_field = struct_array.field_by_name_opt("value").unwrap();
-    assert_eq!(
-        opt_field.to_primitive().as_slice::<i32>(),
-        [1i32, 2, 3] // First "value" field
+    assert_arrays_eq!(
+        opt_field,
+        PrimitiveArray::from_iter([1i32, 2, 3]) // First "value" field
     );
 
     // Verify the third field (second "value") can be accessed by index
     let third_field = &struct_array.fields()[2];
-    assert_eq!(
-        third_field.to_primitive().as_slice::<i32>(),
-        [100i32, 200, 300]
-    );
+    assert_arrays_eq!(third_field, PrimitiveArray::from_iter([100i32, 200, 300]));
 }
 
 #[test]
diff --git a/vortex-array/src/builders/list.rs b/vortex-array/src/builders/list.rs
index 49a54aad916..3333f5d0b75 100644
--- a/vortex-array/src/builders/list.rs
+++ b/vortex-array/src/builders/list.rs
@@ -319,6 +319,8 @@ mod tests {
     use crate::array::Array;
     use crate::arrays::ChunkedArray;
     use crate::arrays::ListArray;
+    use crate::arrays::PrimitiveArray;
+    use crate::assert_arrays_eq;
     use crate::builders::ArrayBuilder;
     use crate::builders::list::ListBuilder;
     use crate::validity::Validity;
@@ -455,15 +457,9 @@ mod tests {
 
         let actual = builder.finish_into_canonical().into_listview();
 
-        assert_eq!(
-            actual.elements().to_primitive().as_slice::<i32>(),
-            expected.elements().to_primitive().as_slice::<i32>()
-        );
+        assert_arrays_eq!(actual.elements(), expected.elements());
 
-        assert_eq!(
-            actual.offsets().to_primitive().as_slice::<O>(),
-            expected.offsets().to_primitive().as_slice::<O>()
-        );
+        assert_arrays_eq!(actual.offsets(), expected.offsets());
 
         assert_eq!(actual.validity(), expected.validity())
     }
@@ -606,12 +602,16 @@ mod tests {
         assert_eq!(list.len(), 5);
 
         // Verify elements array: [1, 2, 3, 10, 11, 4, 5].
-        let elements = list.elements().to_primitive();
-        assert_eq!(elements.as_slice::<i32>(), &[1, 2, 3, 10, 11, 4, 5]);
+        assert_arrays_eq!(
+            list.elements(),
+            PrimitiveArray::from_iter([1i32, 2, 3, 10, 11, 4, 5])
+        );
 
         // Verify offsets array.
-        let offsets = list.offsets().to_primitive();
-        assert_eq!(offsets.as_slice::<u32>(), &[0, 3, 5, 7, 7, 7]);
+        assert_arrays_eq!(
+            list.offsets(),
+            PrimitiveArray::from_iter([0u32, 3, 5, 7, 7, 7])
+        );
 
         // Test dtype mismatch error.
         let mut builder = ListBuilder::<u32>::with_capacity(dtype, NonNullable, 20, 10);
diff --git a/vortex-array/src/builders/listview.rs b/vortex-array/src/builders/listview.rs
index a0814ebfa5b..d434cb5ae51 100644
--- a/vortex-array/src/builders/listview.rs
+++ b/vortex-array/src/builders/listview.rs
@@ -427,6 +427,8 @@ mod tests {
     use crate::IntoArray;
     use crate::array::Array;
     use crate::arrays::ListArray;
+    use crate::arrays::PrimitiveArray;
+    use crate::assert_arrays_eq;
     use crate::builders::ArrayBuilder;
     use crate::vtable::ValidityHelper;
 
@@ -675,8 +677,6 @@ mod tests {
     fn test_append_array_as_list() {
         use vortex_buffer::buffer;
 
-        use crate::ToCanonical;
-
         let dtype: Arc<DType> = Arc::new(I32.into());
         let mut builder =
             ListViewBuilder::<u32, u32>::with_capacity(dtype.clone(), NonNullable, 20, 10);
@@ -710,16 +710,22 @@ mod tests {
         assert_eq!(listview.len(), 5);
 
         // Verify elements array: [1, 2, 3, 10, 11, 4, 5].
-        let elements = listview.elements().to_primitive();
-        assert_eq!(elements.as_slice::<i32>(), &[1, 2, 3, 10, 11, 4, 5]);
+        assert_arrays_eq!(
+            listview.elements(),
+            PrimitiveArray::from_iter([1i32, 2, 3, 10, 11, 4, 5])
+        );
 
         // Verify offsets array.
-        let offsets = listview.offsets().to_primitive();
-        assert_eq!(offsets.as_slice::<u32>(), &[0, 3, 5, 7, 7]);
+        assert_arrays_eq!(
+            listview.offsets(),
+            PrimitiveArray::from_iter([0u32, 3, 5, 7, 7])
+        );
 
         // Verify sizes array.
-        let sizes = listview.sizes().to_primitive();
-        assert_eq!(sizes.as_slice::<u32>(), &[3, 2, 2, 0, 0]);
+        assert_arrays_eq!(
+            listview.sizes(),
+            PrimitiveArray::from_iter([3u32, 2, 2, 0, 0])
+        );
 
         // Test dtype mismatch error.
         let mut builder = ListViewBuilder::<u32, u32>::with_capacity(dtype, NonNullable, 20, 10);
diff --git a/vortex-array/src/builders/primitive.rs b/vortex-array/src/builders/primitive.rs
index 88eed215e1a..b3a6652e404 100644
--- a/vortex-array/src/builders/primitive.rs
+++ b/vortex-array/src/builders/primitive.rs
@@ -345,6 +345,7 @@ impl<T> UninitRange<'_, T> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::assert_arrays_eq;
 
     /// REGRESSION TEST: This test verifies that multiple sequential ranges have correct offsets.
     ///
@@ -381,7 +382,7 @@ mod tests {
         assert_eq!(builder.values(), &[1, 2, 3, 4, 5]);
 
         let array = builder.finish_into_primitive();
-        assert_eq!(array.as_slice::<i32>(), &[1, 2, 3, 4, 5]);
+        assert_arrays_eq!(array, PrimitiveArray::from_iter([1i32, 2, 3, 4, 5]));
     }
 
     /// REGRESSION TEST: This test verifies that `append_mask` was correctly moved from
@@ -457,7 +458,7 @@ mod tests {
         }
 
         let array = builder.finish_into_primitive();
-        assert_eq!(array.as_slice::<i32>(), &[1, 2, 3, 4, 5, 6]);
+        assert_arrays_eq!(array, PrimitiveArray::from_iter([1i32, 2, 3, 4, 5, 6]));
     }
 
     /// Test that `set_bit` uses relative indexing within the range.
diff --git a/vortex-array/src/patches.rs b/vortex-array/src/patches.rs
index e8e5daedbab..32e43a083c1 100644
--- a/vortex-array/src/patches.rs
+++ b/vortex-array/src/patches.rs
@@ -1182,6 +1182,7 @@ mod test {
     use crate::IntoArray;
     use crate::ToCanonical;
     use crate::arrays::PrimitiveArray;
+    use crate::assert_arrays_eq;
     use crate::patches::Patches;
     use crate::search_sorted::SearchResult;
     use crate::validity::Validity;
@@ -1201,10 +1202,8 @@ mod test {
             .unwrap()
             .unwrap();
 
-        let indices = filtered.indices().to_primitive();
-        let values = filtered.values().to_primitive();
-        assert_eq!(indices.as_slice::<u64>(), &[0, 1]);
-        assert_eq!(values.as_slice::<i32>(), &[100, 200]);
+        assert_arrays_eq!(filtered.indices(), PrimitiveArray::from_iter([0u64, 1]));
+        assert_arrays_eq!(filtered.values(), PrimitiveArray::from_iter([100i32, 200]));
     }
 
     #[test]
@@ -1227,8 +1226,11 @@ mod test {
         let primitive_values = taken.values().to_primitive();
         let primitive_indices = taken.indices().to_primitive();
         assert_eq!(taken.array_len(), 2);
-        assert_eq!(primitive_values.as_slice::<i32>(), [44]);
-        assert_eq!(primitive_indices.as_slice::<u64>(), [0]);
+        assert_arrays_eq!(
+            primitive_values,
+            PrimitiveArray::from_option_iter([Some(44i32)])
+        );
+        assert_arrays_eq!(primitive_indices, PrimitiveArray::from_iter([0u64]));
         assert_eq!(
             primitive_values.validity_mask(),
             Mask::from_iter(vec![true])
@@ -1254,10 +1256,12 @@ mod test {
             .unwrap();
 
         let primitive_values = taken.values().to_primitive();
-        let primitive_indices = taken.indices().to_primitive();
         assert_eq!(taken.array_len(), 2);
-        assert_eq!(primitive_values.as_slice::<i32>(), [44, 33]);
-        assert_eq!(primitive_indices.as_slice::<u64>(), [0, 1]);
+        assert_arrays_eq!(
+            primitive_values,
+            PrimitiveArray::from_option_iter([Some(44i32), None])
+        );
+        assert_arrays_eq!(taken.indices(), PrimitiveArray::from_iter([0u64, 1]));
 
         assert_eq!(
             primitive_values.validity_mask(),
@@ -1283,9 +1287,11 @@ mod test {
             .unwrap()
             .unwrap();
 
-        let primitive_values = taken.values().to_primitive();
         assert_eq!(taken.array_len(), 3);
-        assert_eq!(primitive_values.as_slice::<i32>(), [20, 30]);
+        assert_arrays_eq!(
+            taken.values(),
+            PrimitiveArray::from_option_iter([Some(20i32), Some(30)])
+        );
     }
 
     #[test]
@@ -1326,9 +1332,11 @@ mod test {
             .unwrap()
             .unwrap();
 
-        let primitive_values = taken.values().to_primitive();
         assert_eq!(taken.array_len(), 4);
-        assert_eq!(primitive_values.as_slice::<i32>(), [200, 300]);
+        assert_arrays_eq!(
+            taken.values(),
+            PrimitiveArray::from_option_iter([Some(200i32), Some(300)])
+        );
     }
 
     #[test]
@@ -1361,9 +1369,7 @@ mod test {
 
         let sliced = patches.slice(15..100).unwrap();
         assert_eq!(sliced.array_len(), 100 - 15);
-        let primitive = sliced.values().to_primitive();
-
-        assert_eq!(primitive.as_slice::<u32>(), &[13531]);
+        assert_arrays_eq!(sliced.values(), PrimitiveArray::from_iter([13531u32]));
     }
 
     #[test]
@@ -1375,14 +1381,13 @@ mod test {
 
         let sliced = patches.slice(15..100).unwrap();
         assert_eq!(sliced.array_len(), 100 - 15);
-        let primitive = sliced.values().to_primitive();
-
-        assert_eq!(primitive.as_slice::<u32>(), &[13531]);
+        assert_arrays_eq!(sliced.values(), PrimitiveArray::from_iter([13531u32]));
 
         let doubly_sliced = sliced.slice(35..36).unwrap();
-        let primitive_doubly_sliced = doubly_sliced.values().to_primitive();
-
-        assert_eq!(primitive_doubly_sliced.as_slice::<u32>(), &[13531]);
+        assert_arrays_eq!(
+            doubly_sliced.values(),
+            PrimitiveArray::from_iter([13531u32])
+        );
     }
 
     #[test]
@@ -1414,15 +1419,16 @@ mod test {
         let masked = patches.mask(&mask).unwrap().unwrap();
 
         // No patch values should be masked
-        let masked_values = masked.values().to_primitive();
-        assert_eq!(masked_values.as_slice::<i32>(), &[100, 200, 300]);
-        assert!(masked_values.is_valid(0));
-        assert!(masked_values.is_valid(1));
-        assert!(masked_values.is_valid(2));
+        assert_arrays_eq!(
+            masked.values(),
+            PrimitiveArray::from_iter([100i32, 200, 300])
+        );
+        assert!(masked.values().is_valid(0));
+        assert!(masked.values().is_valid(1));
+        assert!(masked.values().is_valid(2));
 
         // Indices should remain unchanged
-        let indices = masked.indices().to_primitive();
-        assert_eq!(indices.as_slice::<u64>(), &[2, 5, 8]);
+        assert_arrays_eq!(masked.indices(), PrimitiveArray::from_iter([2u64, 5, 8]));
     }
 
     #[test]
@@ -1442,13 +1448,11 @@ mod test {
         let masked = patches.mask(&mask).unwrap().unwrap();
 
         // Only the patch at index 5 should remain
-        let masked_values = masked.values().to_primitive();
-        assert_eq!(masked_values.len(), 1);
-        assert_eq!(masked_values.as_slice::<i32>(), &[200]);
+        assert_eq!(masked.values().len(), 1);
+        assert_arrays_eq!(masked.values(), PrimitiveArray::from_iter([200i32]));
 
         // Only index 5 should remain
-        let indices = masked.indices().to_primitive();
-        assert_eq!(indices.as_slice::<u64>(), &[5]);
+        assert_arrays_eq!(masked.indices(), PrimitiveArray::from_iter([5u64]));
     }
 
     #[test]
@@ -1469,10 +1473,8 @@ mod test {
         let masked = patches.mask(&mask).unwrap().unwrap();
         assert_eq!(masked.array_len(), 10);
         assert_eq!(masked.offset(), 5);
-        let indices = masked.indices().to_primitive();
-        assert_eq!(indices.as_slice::<u64>(), &[10, 13]);
-        let masked_values = masked.values().to_primitive();
-        assert_eq!(masked_values.as_slice::<i32>(), &[200, 300]);
+        assert_arrays_eq!(masked.indices(), PrimitiveArray::from_iter([10u64, 13]));
+        assert_arrays_eq!(masked.values(), PrimitiveArray::from_iter([200i32, 300]));
     }
 
     #[test]
@@ -1492,8 +1494,7 @@ mod test {
         let masked = patches.mask(&mask).unwrap().unwrap();
 
         // Patches at indices 5 and 8 should remain
-        let indices = masked.indices().to_primitive();
-        assert_eq!(indices.as_slice::<u64>(), &[5, 8]);
+        assert_arrays_eq!(masked.indices(), PrimitiveArray::from_iter([5u64, 8]));
 
         // Values should be the null and 300
         let masked_values = masked.values().to_primitive();
@@ -1517,10 +1518,11 @@ mod test {
         let mask = Mask::from_indices(10, (0..10).collect());
         let filtered = patches.filter(&mask).unwrap().unwrap();
 
-        let indices = filtered.indices().to_primitive();
-        let values = filtered.values().to_primitive();
-        assert_eq!(indices.as_slice::<u64>(), &[2, 5, 8]);
-        assert_eq!(values.as_slice::<i32>(), &[100, 200, 300]);
+        assert_arrays_eq!(filtered.indices(), PrimitiveArray::from_iter([2u64, 5, 8]));
+        assert_arrays_eq!(
+            filtered.values(),
+            PrimitiveArray::from_iter([100i32, 200, 300])
+        );
     }
 
     #[test]
@@ -1553,10 +1555,8 @@ mod test {
         let mask = Mask::from_indices(10, vec![2, 5, 9]);
         let filtered = patches.filter(&mask).unwrap().unwrap();
 
-        let indices = filtered.indices().to_primitive();
-        let values = filtered.values().to_primitive();
-        assert_eq!(indices.as_slice::<u64>(), &[0, 1]); // Adjusted indices
-        assert_eq!(values.as_slice::<i32>(), &[100, 200]);
+        assert_arrays_eq!(filtered.indices(), PrimitiveArray::from_iter([0u64, 1])); // Adjusted indices
+        assert_arrays_eq!(filtered.values(), PrimitiveArray::from_iter([100i32, 200]));
     }
 
     #[test]
@@ -1571,10 +1571,11 @@ mod test {
 
         let sliced = patches.slice(0..10).unwrap();
 
-        let indices = sliced.indices().to_primitive();
-        let values = sliced.values().to_primitive();
-        assert_eq!(indices.as_slice::<u64>(), &[2, 5, 8]);
-        assert_eq!(values.as_slice::<i32>(), &[100, 200, 300]);
+        assert_arrays_eq!(sliced.indices(), PrimitiveArray::from_iter([2u64, 5, 8]));
+        assert_arrays_eq!(
+            sliced.values(),
+            PrimitiveArray::from_iter([100i32, 200, 300])
+        );
     }
 
     #[test]
@@ -1590,10 +1591,8 @@ mod test {
         // Slice from 3 to 8 (includes patch at 5)
         let sliced = patches.slice(3..8).unwrap();
 
-        let indices = sliced.indices().to_primitive();
-        let values = sliced.values().to_primitive();
-        assert_eq!(indices.as_slice::<u64>(), &[5]); // Index stays the same
-        assert_eq!(values.as_slice::<i32>(), &[200]);
+        assert_arrays_eq!(sliced.indices(), PrimitiveArray::from_iter([5u64])); // Index stays the same
+        assert_arrays_eq!(sliced.values(), PrimitiveArray::from_iter([200i32]));
         assert_eq!(sliced.array_len(), 5); // 8 - 3 = 5
         assert_eq!(sliced.offset(), 3); // New offset
     }
@@ -1626,10 +1625,8 @@ mod test {
         // Slice from 3 to 8 (includes patch at actual index 5)
         let sliced = patches.slice(3..8).unwrap();
 
-        let indices = sliced.indices().to_primitive();
-        let values = sliced.values().to_primitive();
-        assert_eq!(indices.as_slice::<u64>(), &[10]); // Index stays the same (offset + 5 = 10)
-        assert_eq!(values.as_slice::<i32>(), &[200]);
+        assert_arrays_eq!(sliced.indices(), PrimitiveArray::from_iter([10u64])); // Index stays the same (offset + 5 = 10)
+        assert_arrays_eq!(sliced.values(), PrimitiveArray::from_iter([200i32]));
         assert_eq!(sliced.offset(), 8); // New offset = 5 + 3
     }
 
@@ -1702,10 +1699,8 @@ mod test {
         let masked = patches.mask(&mask).unwrap();
         assert!(masked.is_some());
         let masked = masked.unwrap();
-        let indices = masked.indices().to_primitive();
-        assert_eq!(indices.as_slice::<u64>(), &[9]);
-        let values = masked.values().to_primitive();
-        assert_eq!(values.as_slice::<i32>(), &[200]);
+        assert_arrays_eq!(masked.indices(), PrimitiveArray::from_iter([9u64]));
+        assert_arrays_eq!(masked.values(), PrimitiveArray::from_iter([200i32]));
     }
 
     #[test]
@@ -1744,10 +1739,11 @@ mod test {
         ]);
         let masked = patches.mask(&mask).unwrap().unwrap();
 
-        let indices = masked.indices().to_primitive();
-        assert_eq!(indices.as_slice::<u64>(), &[2, 5, 8]);
-        let values = masked.values().to_primitive();
-        assert_eq!(values.as_slice::<i32>(), &[100, 200, 300]);
+        assert_arrays_eq!(masked.indices(), PrimitiveArray::from_iter([2u64, 5, 8]));
+        assert_arrays_eq!(
+            masked.values(),
+            PrimitiveArray::from_iter([100i32, 200, 300])
+        );
     }
 
     #[test]
@@ -1769,8 +1765,7 @@ mod test {
         // Mask that keeps the single patch
         let mask = Mask::from_iter([true, false, false, true, false]);
         let masked = patches.mask(&mask).unwrap().unwrap();
-        let indices = masked.indices().to_primitive();
-        assert_eq!(indices.as_slice::<u64>(), &[2]);
+        assert_arrays_eq!(masked.indices(), PrimitiveArray::from_iter([2u64]));
     }
 
     #[test]
@@ -1790,10 +1785,8 @@ mod test {
         ]);
         let masked = patches.mask(&mask).unwrap().unwrap();
 
-        let indices = masked.indices().to_primitive();
-        assert_eq!(indices.as_slice::<u64>(), &[3, 6]);
-        let values = masked.values().to_primitive();
-        assert_eq!(values.as_slice::<i32>(), &[100, 400]);
+        assert_arrays_eq!(masked.indices(), PrimitiveArray::from_iter([3u64, 6]));
+        assert_arrays_eq!(masked.values(), PrimitiveArray::from_iter([100i32, 400]));
     }
 
     #[test]
@@ -1814,10 +1807,8 @@ mod test {
         ]);
         let masked = patches.mask(&mask).unwrap().unwrap();
 
-        let indices = masked.indices().to_primitive();
-        assert_eq!(indices.as_slice::<u64>(), &[16, 19]);
-        let values = masked.values().to_primitive();
-        assert_eq!(values.as_slice::<i32>(), &[100, 300]);
+        assert_arrays_eq!(masked.indices(), PrimitiveArray::from_iter([16u64, 19]));
+        assert_arrays_eq!(masked.values(), PrimitiveArray::from_iter([100i32, 300]));
     }
 
     #[test]
diff --git a/vortex-duckdb/Cargo.toml b/vortex-duckdb/Cargo.toml
index dd112d63c99..1804f829a9f 100644
--- a/vortex-duckdb/Cargo.toml
+++ b/vortex-duckdb/Cargo.toml
@@ -44,6 +44,7 @@ vortex-utils = { workspace = true, features = ["dashmap"] }
 [dev-dependencies]
 jiff = { workspace = true }
 rstest = { workspace = true }
+vortex-array = { workspace = true, features = ["test-harness"] }
 vortex-runend = { workspace = true }
 vortex-sequence = { workspace = true }
 
diff --git a/vortex-duckdb/src/convert/vector.rs b/vortex-duckdb/src/convert/vector.rs
index ee217c3cb8b..08ecc8781eb 100644
--- a/vortex-duckdb/src/convert/vector.rs
+++ b/vortex-duckdb/src/convert/vector.rs
@@ -379,6 +379,7 @@ mod tests {
     use vortex::array::arrays::PrimitiveVTable;
     use vortex::error::VortexExpect;
     use vortex::mask::Mask;
+    use vortex_array::assert_arrays_eq;
 
     use super::*;
     use crate::cpp::DUCKDB_TYPE;
@@ -640,12 +641,9 @@ mod tests {
         let vortex_array = result.to_listview();
 
         assert_eq!(vortex_array.len(), len);
-        assert_eq!(
-            vortex_array
-                .list_elements_at(0)
-                .to_primitive()
-                .as_slice::<i32>(),
-            &[1, 2, 3, 4]
+        assert_arrays_eq!(
+            vortex_array.list_elements_at(0),
+            PrimitiveArray::from_option_iter([Some(1i32), Some(2), Some(3), Some(4)])
         );
     }
 
@@ -671,12 +669,9 @@ mod tests {
         let vortex_array = result.to_fixed_size_list();
 
         assert_eq!(vortex_array.len(), len);
-        assert_eq!(
-            vortex_array
-                .fixed_size_list_elements_at(0)
-                .to_primitive()
-                .as_slice::<i32>(),
-            &[1, 2, 3, 4]
+        assert_arrays_eq!(
+            vortex_array.fixed_size_list_elements_at(0),
+            PrimitiveArray::from_option_iter([Some(1i32), Some(2), Some(3), Some(4)])
         );
     }
 
@@ -728,13 +723,13 @@ mod tests {
 
         assert_eq!(vortex_array.len(), len);
         assert_eq!(vortex_array.fields().len(), 2);
-        assert_eq!(
-            vortex_array.fields()[0].to_primitive().as_slice::<i32>(),
-            &[1, 2, 3, 4]
+        assert_arrays_eq!(
+            &vortex_array.fields()[0],
+            PrimitiveArray::from_option_iter([Some(1i32), Some(2), Some(3), Some(4)])
         );
-        assert_eq!(
-            vortex_array.fields()[1].to_primitive().as_slice::<i32>(),
-            &[5, 6, 7, 8]
+        assert_arrays_eq!(
+            &vortex_array.fields()[1],
+            PrimitiveArray::from_option_iter([Some(5i32), Some(6), Some(7), Some(8)])
         );
     }
 
@@ -776,12 +771,9 @@ mod tests {
         let vortex_array = result.to_listview();
 
         assert_eq!(vortex_array.len(), len);
-        assert_eq!(
-            vortex_array
-                .list_elements_at(0)
-                .to_primitive()
-                .as_slice::<i32>(),
-            &[1, 2, 3, 4]
+        assert_arrays_eq!(
+            vortex_array.list_elements_at(0),
+            PrimitiveArray::from_option_iter([Some(1i32), Some(2), Some(3), Some(4)])
         );
         assert_eq!(vortex_array.validity_mask(), Mask::from_indices(2, vec![0]));
     }
@@ -821,19 +813,13 @@ mod tests {
         let vortex_array = result.to_listview();
 
         assert_eq!(vortex_array.len(), len);
-        assert_eq!(
-            vortex_array
-                .list_elements_at(0)
-                .to_primitive()
-                .as_slice::<i32>(),
-            &[3, 4]
+        assert_arrays_eq!(
+            vortex_array.list_elements_at(0),
+            PrimitiveArray::from_option_iter([Some(3i32), Some(4)])
         );
-        assert_eq!(
-            vortex_array
-                .list_elements_at(1)
-                .to_primitive()
-                .as_slice::<i32>(),
-            &[1, 2]
+        assert_arrays_eq!(
+            vortex_array.list_elements_at(1),
+            PrimitiveArray::from_option_iter([Some(1i32), Some(2)])
         );
     }
 
@@ -884,19 +870,13 @@ mod tests {
         assert_eq!(vortex_array.len(), len);
 
         // Valid entries should work correctly.
-        assert_eq!(
-            vortex_array
-                .list_elements_at(0)
-                .to_primitive()
-                .as_slice::<i32>(),
-            &[1, 2]
+        assert_arrays_eq!(
+            vortex_array.list_elements_at(0),
+            PrimitiveArray::from_option_iter([Some(1i32), Some(2)])
         );
-        assert_eq!(
-            vortex_array
-                .list_elements_at(2)
-                .to_primitive()
-                .as_slice::<i32>(),
-            &[3, 4]
+        assert_arrays_eq!(
+            vortex_array.list_elements_at(2),
+            PrimitiveArray::from_option_iter([Some(3i32), Some(4)])
         );
 
         // Verify the null entry has sanitized offset/size (offset=2, size=0) rather than garbage.
diff --git a/vortex-gpu/src/rle_decompress.rs b/vortex-gpu/src/rle_decompress.rs
index 94244022830..60a2576f768 100644
--- a/vortex-gpu/src/rle_decompress.rs
+++ b/vortex-gpu/src/rle_decompress.rs
@@ -212,6 +212,7 @@ mod tests {
     use cudarc::driver::CudaContext;
     use rstest::rstest;
     use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::assert_arrays_eq;
     use vortex_array::validity::Validity;
     use vortex_buffer::Buffer;
     use vortex_dtype::NativePType;
@@ -237,6 +238,6 @@ mod tests {
         let ctx = CudaContext::new(0).unwrap();
         ctx.set_blocking_synchronize().unwrap();
         let unpacked = cuda_rle_decompress(&array, ctx).unwrap();
-        assert_eq!(primitive_array.as_slice::<T>(), unpacked.as_slice::<T>());
+        assert_arrays_eq!(unpacked, primitive_array);
     }
 }
diff --git a/vortex-layout/src/layouts/compact.rs b/vortex-layout/src/layouts/compact.rs
index dd55a7e33f5..a0b5d002800 100644
--- a/vortex-layout/src/layouts/compact.rs
+++ b/vortex-layout/src/layouts/compact.rs
@@ -206,7 +206,6 @@ impl Default for CompactCompressor {
 #[cfg(test)]
 mod tests {
     use vortex_array::IntoArray;
-    use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::StructArray;
     use vortex_array::assert_arrays_eq;
@@ -236,7 +235,7 @@ mod tests {
 
         let n_rows = columns[0].len();
         let struct_array = StructArray::try_new(
-            field_names.clone().into(),
+            field_names.into(),
             columns.clone(),
             n_rows,
             Validity::NonNullable,
@@ -246,18 +245,6 @@ mod tests {
         // Compress the struct array
         let compressed = compressor.compress(struct_array.as_ref()).unwrap();
 
-        // Verify we can decompress back to original
-        let decompressed = compressed.to_canonical().into_array();
-        assert_eq!(decompressed.len(), n_rows);
-        let decompressed_struct = decompressed.to_struct();
-
-        // Verify each field can be accessed and has correct data
-        for (i, name) in decompressed_struct.names().iter().enumerate() {
-            assert_eq!(name, field_names[i]);
-            let decompressed_array = decompressed_struct.field_by_name(name).unwrap().clone();
-            assert_eq!(decompressed_array.len(), n_rows);
-
-            assert_arrays_eq!(decompressed_array.as_ref(), columns[i].as_ref());
-        }
+        assert_arrays_eq!(struct_array, compressed)
     }
 }