Stop ignoring tests

vortex-array/src/arrays/filter/execute/listview.rs

@@ -71,22 +71,27 @@ pub fn filter_listview(array: &ListViewArray, selection_mask: &Arc<MaskValues>)
 
 #[cfg(test)]
 mod test {
+    use std::sync::LazyLock;
+
     use vortex_buffer::buffer;
     use vortex_mask::Mask;
+    use vortex_session::VortexSession;
 
     use crate::IntoArray;
     use crate::LEGACY_SESSION;
-    #[expect(deprecated)]
-    use crate::ToCanonical as _;
     use crate::VortexSessionExecute;
     use crate::arrays::ListViewArray;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::filter::execute::ConstantArray;
     use crate::arrays::listview::ListViewArrayExt;
     use crate::assert_arrays_eq;
     use crate::compute::conformance::filter::test_filter_conformance;
+    use crate::session::ArraySession;
     use crate::validity::Validity;
 
+    static SESSION: LazyLock<VortexSession> =
+        LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
     #[test]
     fn test_filter_listview_conformance() {
         // 3 lists: [1,2], [3,4], [5,6]
@@ -170,7 +175,6 @@ mod test {
         assert_arrays_eq!(filtered, expected);
     }
 
-    #[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `filter`"]
     #[test]
     fn test_filter_preserves_unreferenced_elements() {
         // ListView-specific: Test that filter preserves the entire elements array.
@@ -187,8 +191,9 @@ mod test {
         // Filter to keep only 2 lists.
         let mask = Mask::from_iter([true, false, false, true, false]);
         let result = listview.filter(mask).unwrap();
-        #[expect(deprecated)]
-        let result_list = result.to_listview();
+        let result_list = result
+            .execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
+            .unwrap();
 
         assert_eq!(result_list.len(), 2, "Wrong number of filtered lists");
 
@@ -203,7 +208,6 @@ mod test {
         assert_eq!(result_list.offset_at(1), 0, "Wrong offset at index 3");
     }
 
-    #[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `filter`"]
     #[test]
     fn test_filter_with_gaps() {
         // ListView-specific: Test filtering with gaps in elements array.
@@ -220,8 +224,9 @@ mod test {
         // Filter to keep lists with gaps and overlaps.
         let mask = Mask::from_iter([false, true, true, true, false]);
         let result = listview.filter(mask).unwrap();
-        #[expect(deprecated)]
-        let result_list = result.to_listview();
+        let result_list = result
+            .execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
+            .unwrap();
 
         assert_eq!(result_list.len(), 3, "Wrong filter result length");
 
@@ -243,7 +248,6 @@ mod test {
         );
     }
 
-    #[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `filter`"]
     #[test]
     fn test_filter_constant_arrays() {
         // ListView-specific: Test filter with ConstantArray for offsets/sizes.
@@ -264,8 +268,9 @@ mod test {
 
         let mask1 = Mask::from_iter([true, false, true, false]);
         let result1 = const_offset_list.filter(mask1).unwrap();
-        #[expect(deprecated)]
-        let result1_list = result1.to_listview();
+        let result1_list = result1
+            .execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
+            .unwrap();
 
         assert_eq!(result1_list.len(), 2);
         assert_eq!(result1_list.offset_at(0), 2); // Both offsets are 2
@@ -288,8 +293,9 @@ mod test {
 
         let mask2 = Mask::from_iter([true, false, true]);
         let result2 = both_const_list.filter(mask2).unwrap();
-        #[expect(deprecated)]
-        let result2_list = result2.to_listview();
+        let result2_list = result2
+            .execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
+            .unwrap();
 
         assert_eq!(result2_list.len(), 2);
         assert_eq!(result2_list.offset_at(0), 1);
@@ -298,7 +304,6 @@ mod test {
         assert_eq!(result2_list.size_at(1), 3);
     }
 
-    #[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `filter`"]
     #[test]
     fn test_filter_extreme_offsets() {
         // ListView-specific: Test with very large offsets.
@@ -315,8 +320,9 @@ mod test {
         // Filter to keep only 2 lists, demonstrating we keep all 10000 elements.
         let mask = Mask::from_iter([false, true, false, false, true]);
         let result = listview.filter(mask).unwrap();
-        #[expect(deprecated)]
-        let result_list = result.to_listview();
+        let result_list = result
+            .execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
+            .unwrap();
 
         assert_eq!(result_list.len(), 2);
 
@@ -351,8 +357,9 @@ mod test {
         // Test sparse selection from large dataset.
         let sparse_mask = Mask::from_iter((0..5).map(|i| i == 0 || i == 4));
         let sparse_result = listview.filter(sparse_mask).unwrap();
-        #[expect(deprecated)]
-        let sparse_list = sparse_result.to_listview();
+        let sparse_list = sparse_result
+            .execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
+            .unwrap();
 
         assert_eq!(sparse_list.len(), 2);
         assert_eq!(sparse_list.offset_at(0), 0); // First list

vortex-array/src/arrays/listview/tests/filter.rs

@@ -1,9 +1,12 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::sync::LazyLock;
+
 use rstest::rstest;
 use vortex_buffer::buffer;
 use vortex_mask::Mask;
+use vortex_session::VortexSession;
 
 use super::common::create_basic_listview;
 use super::common::create_empty_lists_listview;
@@ -12,17 +15,19 @@ use super::common::create_nullable_listview;
 use super::common::create_overlapping_listview;
 use crate::IntoArray;
 use crate::LEGACY_SESSION;
-#[expect(deprecated)]
-use crate::ToCanonical as _;
 use crate::VortexSessionExecute;
 use crate::arrays::ConstantArray;
 use crate::arrays::ListViewArray;
 use crate::arrays::PrimitiveArray;
 use crate::arrays::listview::ListViewArrayExt;
 use crate::assert_arrays_eq;
 use crate::compute::conformance::filter::test_filter_conformance;
+use crate::session::ArraySession;
 use crate::validity::Validity;
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 // Conformance tests for common filter scenarios.
 #[rstest]
 #[case::basic(create_basic_listview())]
@@ -34,7 +39,6 @@ fn test_filter_listview_conformance(#[case] listview: ListViewArray) {
     test_filter_conformance(&listview.into_array());
 }
 
-#[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `filter`"]
 #[test]
 fn test_filter_preserves_unreferenced_elements() {
     // ListView-specific: Test that filter preserves the entire elements array.
@@ -50,8 +54,9 @@ fn test_filter_preserves_unreferenced_elements() {
     // Filter to keep only 2 lists.
     let mask = Mask::from_iter([true, false, false, true, false]);
     let result = listview.filter(mask).unwrap();
-    #[expect(deprecated)]
-    let result_list = result.to_listview();
+    let result_list = result
+        .execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
+        .unwrap();
 
     assert_eq!(result_list.len(), 2, "Wrong number of filtered lists");
 
@@ -66,7 +71,6 @@ fn test_filter_preserves_unreferenced_elements() {
     assert_eq!(result_list.offset_at(1), 0, "Wrong offset at index 3");
 }
 
-#[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `filter`"]
 #[test]
 fn test_filter_with_gaps() {
     // ListView-specific: Test filtering with gaps in elements array.
@@ -82,8 +86,9 @@ fn test_filter_with_gaps() {
     // Filter to keep lists with gaps and overlaps.
     let mask = Mask::from_iter([false, true, true, true, false]);
     let result = listview.filter(mask).unwrap();
-    #[expect(deprecated)]
-    let result_list = result.to_listview();
+    let result_list = result
+        .execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
+        .unwrap();
 
     assert_eq!(result_list.len(), 3, "Wrong filter result length");
 
@@ -105,7 +110,6 @@ fn test_filter_with_gaps() {
     );
 }
 
-#[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `filter`"]
 #[test]
 fn test_filter_constant_arrays() {
     // ListView-specific: Test filter with ConstantArray for offsets/sizes.
@@ -126,8 +130,9 @@ fn test_filter_constant_arrays() {
 
     let mask1 = Mask::from_iter([true, false, true, false]);
     let result1 = const_offset_list.filter(mask1).unwrap();
-    #[expect(deprecated)]
-    let result1_list = result1.to_listview();
+    let result1_list = result1
+        .execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
+        .unwrap();
 
     assert_eq!(result1_list.len(), 2);
     assert_eq!(result1_list.offset_at(0), 2); // Both offsets are 2
@@ -150,8 +155,9 @@ fn test_filter_constant_arrays() {
 
     let mask2 = Mask::from_iter([true, false, true]);
     let result2 = both_const_list.filter(mask2).unwrap();
-    #[expect(deprecated)]
-    let result2_list = result2.to_listview();
+    let result2_list = result2
+        .execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
+        .unwrap();
 
     assert_eq!(result2_list.len(), 2);
     assert_eq!(result2_list.offset_at(0), 1);
@@ -160,7 +166,6 @@ fn test_filter_constant_arrays() {
     assert_eq!(result2_list.size_at(1), 3);
 }
 
-#[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `filter`"]
 #[test]
 fn test_filter_extreme_offsets() {
     // ListView-specific: Test with very large offsets.
@@ -176,8 +181,9 @@ fn test_filter_extreme_offsets() {
     // Filter to keep only 2 lists, demonstrating we keep all 10000 elements.
     let mask = Mask::from_iter([false, true, false, false, true]);
     let result = listview.filter(mask).unwrap();
-    #[expect(deprecated)]
-    let result_list = result.to_listview();
+    let result_list = result
+        .execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
+        .unwrap();
 
     assert_eq!(result_list.len(), 2);
 
@@ -212,8 +218,9 @@ fn test_filter_extreme_offsets() {
     // Test sparse selection from large dataset.
     let sparse_mask = Mask::from_iter((0..5).map(|i| i == 0 || i == 4));
     let sparse_result = listview.filter(sparse_mask).unwrap();
-    #[expect(deprecated)]
-    let sparse_list = sparse_result.to_listview();
+    let sparse_list = sparse_result
+        .execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
+        .unwrap();
 
     assert_eq!(sparse_list.len(), 2);
     assert_eq!(sparse_list.offset_at(0), 0); // First list

vortex-array/src/arrays/listview/tests/take.rs

@@ -1,8 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::sync::LazyLock;
+
 use rstest::rstest;
 use vortex_buffer::buffer;
+use vortex_session::VortexSession;
 
 use super::common::create_basic_listview;
 use super::common::create_empty_lists_listview;
@@ -11,17 +14,19 @@ use super::common::create_nullable_listview;
 use super::common::create_overlapping_listview;
 use crate::IntoArray;
 use crate::LEGACY_SESSION;
-#[expect(deprecated)]
-use crate::ToCanonical as _;
 use crate::VortexSessionExecute;
 use crate::arrays::ConstantArray;
 use crate::arrays::ListViewArray;
 use crate::arrays::PrimitiveArray;
 use crate::arrays::listview::ListViewArrayExt;
 use crate::assert_arrays_eq;
 use crate::compute::conformance::take::test_take_conformance;
+use crate::session::ArraySession;
 use crate::validity::Validity;
 
+static SESSION: LazyLock<VortexSession> =
+    LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
 // Conformance tests for common take scenarios.
 #[rstest]
 #[case::basic(create_basic_listview())]
@@ -35,7 +40,6 @@ fn test_take_listview_conformance(#[case] listview: ListViewArray) {
 
 // ListView-specific tests that aren't covered by conformance.
 
-#[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `take`"]
 #[test]
 fn test_take_preserves_unreferenced_elements() {
     // ListView-specific: Test that take preserves the entire elements array
@@ -49,8 +53,9 @@ fn test_take_preserves_unreferenced_elements() {
     // Take only 2 lists.
     let indices = buffer![1u32, 3].into_array();
     let result = listview.take(indices).unwrap();
-    #[expect(deprecated)]
-    let result_list = result.to_listview();
+    let result_list = result
+        .execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
+        .unwrap();
 
     assert_eq!(result_list.len(), 2);
 
@@ -65,7 +70,6 @@ fn test_take_preserves_unreferenced_elements() {
     assert_eq!(result_list.offset_at(1), 0); // List 3
 }
 
-#[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `take`"]
 #[test]
 fn test_take_with_gaps() {
     // ListView-specific: Test with gaps in elements array.
@@ -78,8 +82,9 @@ fn test_take_with_gaps() {
 
     let indices = buffer![1u32, 3, 4, 2].into_array();
     let result = listview.take(indices).unwrap();
-    #[expect(deprecated)]
-    let result_list = result.to_listview();
+    let result_list = result
+        .execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
+        .unwrap();
 
     // Verify the entire elements array is preserved including gaps.
     assert_arrays_eq!(
@@ -94,7 +99,6 @@ fn test_take_with_gaps() {
     );
 }
 
-#[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `take`"]
 #[test]
 fn test_take_constant_arrays() {
     // ListView-specific: Test with ConstantArray for offsets/sizes.
@@ -114,8 +118,9 @@ fn test_take_constant_arrays() {
 
     let indices = buffer![3u32, 0, 2].into_array();
     let result = const_offset_list.take(indices).unwrap();
-    #[expect(deprecated)]
-    let result_list = result.to_listview();
+    let result_list = result
+        .execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
+        .unwrap();
 
     assert_eq!(result_list.len(), 3);
     assert_eq!(result_list.offset_at(0), 2); // All offsets are 2
@@ -139,8 +144,9 @@ fn test_take_constant_arrays() {
 
     let indices2 = buffer![2u32, 0].into_array();
     let result2 = both_const_list.take(indices2).unwrap();
-    #[expect(deprecated)]
-    let result2_list = result2.to_listview();
+    let result2_list = result2
+        .execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
+        .unwrap();
 
     assert_eq!(result2_list.len(), 2);
     assert_eq!(result2_list.offset_at(0), 1);
@@ -149,7 +155,6 @@ fn test_take_constant_arrays() {
     assert_eq!(result2_list.size_at(1), 3);
 }
 
-#[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `take`"]
 #[test]
 fn test_take_extreme_offsets() {
     // ListView-specific: Test with very large offsets to demonstrate
@@ -165,8 +170,9 @@ fn test_take_extreme_offsets() {
     // Take only 2 lists, demonstrating we keep all 10000 elements.
     let indices = buffer![1u32, 4].into_array();
     let result = listview.take(indices).unwrap();
-    #[expect(deprecated)]
-    let result_list = result.to_listview();
+    let result_list = result
+        .execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
+        .unwrap();
 
     assert_eq!(result_list.len(), 2);