Skip to content

Commit fb2feb2

Browse files
robert3005robert3005
authored
Stop ignoring tests (#7844)
These were ignored for reasons unknown. I removed ignores, fixed one case of actually failing test and converted one of them to an expected panic fix #7835 Signed-off-by: Robert Kruszewski <github@robertk.io>
1 parent b212667 commit fb2feb2

9 files changed

Lines changed: 96 additions & 75 deletions

File tree

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

Lines changed: 25 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -71,22 +71,27 @@ pub fn filter_listview(array: &ListViewArray, selection_mask: &Arc<MaskValues>)
7171

7272
#[cfg(test)]
7373
mod test {
74+
use std::sync::LazyLock;
75+
7476
use vortex_buffer::buffer;
7577
use vortex_mask::Mask;
78+
use vortex_session::VortexSession;
7679

7780
use crate::IntoArray;
7881
use crate::LEGACY_SESSION;
79-
#[expect(deprecated)]
80-
use crate::ToCanonical as _;
8182
use crate::VortexSessionExecute;
8283
use crate::arrays::ListViewArray;
8384
use crate::arrays::PrimitiveArray;
8485
use crate::arrays::filter::execute::ConstantArray;
8586
use crate::arrays::listview::ListViewArrayExt;
8687
use crate::assert_arrays_eq;
8788
use crate::compute::conformance::filter::test_filter_conformance;
89+
use crate::session::ArraySession;
8890
use crate::validity::Validity;
8991

92+
static SESSION: LazyLock<VortexSession> =
93+
LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
94+
9095
#[test]
9196
fn test_filter_listview_conformance() {
9297
// 3 lists: [1,2], [3,4], [5,6]
@@ -170,7 +175,6 @@ mod test {
170175
assert_arrays_eq!(filtered, expected);
171176
}
172177

173-
#[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `filter`"]
174178
#[test]
175179
fn test_filter_preserves_unreferenced_elements() {
176180
// ListView-specific: Test that filter preserves the entire elements array.
@@ -187,8 +191,9 @@ mod test {
187191
// Filter to keep only 2 lists.
188192
let mask = Mask::from_iter([true, false, false, true, false]);
189193
let result = listview.filter(mask).unwrap();
190-
#[expect(deprecated)]
191-
let result_list = result.to_listview();
194+
let result_list = result
195+
.execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
196+
.unwrap();
192197

193198
assert_eq!(result_list.len(), 2, "Wrong number of filtered lists");
194199

@@ -203,7 +208,6 @@ mod test {
203208
assert_eq!(result_list.offset_at(1), 0, "Wrong offset at index 3");
204209
}
205210

206-
#[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `filter`"]
207211
#[test]
208212
fn test_filter_with_gaps() {
209213
// ListView-specific: Test filtering with gaps in elements array.
@@ -220,8 +224,9 @@ mod test {
220224
// Filter to keep lists with gaps and overlaps.
221225
let mask = Mask::from_iter([false, true, true, true, false]);
222226
let result = listview.filter(mask).unwrap();
223-
#[expect(deprecated)]
224-
let result_list = result.to_listview();
227+
let result_list = result
228+
.execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
229+
.unwrap();
225230

226231
assert_eq!(result_list.len(), 3, "Wrong filter result length");
227232

@@ -243,7 +248,6 @@ mod test {
243248
);
244249
}
245250

246-
#[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `filter`"]
247251
#[test]
248252
fn test_filter_constant_arrays() {
249253
// ListView-specific: Test filter with ConstantArray for offsets/sizes.
@@ -264,8 +268,9 @@ mod test {
264268

265269
let mask1 = Mask::from_iter([true, false, true, false]);
266270
let result1 = const_offset_list.filter(mask1).unwrap();
267-
#[expect(deprecated)]
268-
let result1_list = result1.to_listview();
271+
let result1_list = result1
272+
.execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
273+
.unwrap();
269274

270275
assert_eq!(result1_list.len(), 2);
271276
assert_eq!(result1_list.offset_at(0), 2); // Both offsets are 2
@@ -288,8 +293,9 @@ mod test {
288293

289294
let mask2 = Mask::from_iter([true, false, true]);
290295
let result2 = both_const_list.filter(mask2).unwrap();
291-
#[expect(deprecated)]
292-
let result2_list = result2.to_listview();
296+
let result2_list = result2
297+
.execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
298+
.unwrap();
293299

294300
assert_eq!(result2_list.len(), 2);
295301
assert_eq!(result2_list.offset_at(0), 1);
@@ -298,7 +304,6 @@ mod test {
298304
assert_eq!(result2_list.size_at(1), 3);
299305
}
300306

301-
#[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `filter`"]
302307
#[test]
303308
fn test_filter_extreme_offsets() {
304309
// ListView-specific: Test with very large offsets.
@@ -315,8 +320,9 @@ mod test {
315320
// Filter to keep only 2 lists, demonstrating we keep all 10000 elements.
316321
let mask = Mask::from_iter([false, true, false, false, true]);
317322
let result = listview.filter(mask).unwrap();
318-
#[expect(deprecated)]
319-
let result_list = result.to_listview();
323+
let result_list = result
324+
.execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
325+
.unwrap();
320326

321327
assert_eq!(result_list.len(), 2);
322328

@@ -351,8 +357,9 @@ mod test {
351357
// Test sparse selection from large dataset.
352358
let sparse_mask = Mask::from_iter((0..5).map(|i| i == 0 || i == 4));
353359
let sparse_result = listview.filter(sparse_mask).unwrap();
354-
#[expect(deprecated)]
355-
let sparse_list = sparse_result.to_listview();
360+
let sparse_list = sparse_result
361+
.execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
362+
.unwrap();
356363

357364
assert_eq!(sparse_list.len(), 2);
358365
assert_eq!(sparse_list.offset_at(0), 0); // First list

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

Lines changed: 25 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,12 @@
11
// SPDX-License-Identifier: Apache-2.0
22
// SPDX-FileCopyrightText: Copyright the Vortex contributors
33

4+
use std::sync::LazyLock;
5+
46
use rstest::rstest;
57
use vortex_buffer::buffer;
68
use vortex_mask::Mask;
9+
use vortex_session::VortexSession;
710

811
use super::common::create_basic_listview;
912
use super::common::create_empty_lists_listview;
@@ -12,17 +15,19 @@ use super::common::create_nullable_listview;
1215
use super::common::create_overlapping_listview;
1316
use crate::IntoArray;
1417
use crate::LEGACY_SESSION;
15-
#[expect(deprecated)]
16-
use crate::ToCanonical as _;
1718
use crate::VortexSessionExecute;
1819
use crate::arrays::ConstantArray;
1920
use crate::arrays::ListViewArray;
2021
use crate::arrays::PrimitiveArray;
2122
use crate::arrays::listview::ListViewArrayExt;
2223
use crate::assert_arrays_eq;
2324
use crate::compute::conformance::filter::test_filter_conformance;
25+
use crate::session::ArraySession;
2426
use crate::validity::Validity;
2527

28+
static SESSION: LazyLock<VortexSession> =
29+
LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
30+
2631
// Conformance tests for common filter scenarios.
2732
#[rstest]
2833
#[case::basic(create_basic_listview())]
@@ -34,7 +39,6 @@ fn test_filter_listview_conformance(#[case] listview: ListViewArray) {
3439
test_filter_conformance(&listview.into_array());
3540
}
3641

37-
#[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `filter`"]
3842
#[test]
3943
fn test_filter_preserves_unreferenced_elements() {
4044
// ListView-specific: Test that filter preserves the entire elements array.
@@ -50,8 +54,9 @@ fn test_filter_preserves_unreferenced_elements() {
5054
// Filter to keep only 2 lists.
5155
let mask = Mask::from_iter([true, false, false, true, false]);
5256
let result = listview.filter(mask).unwrap();
53-
#[expect(deprecated)]
54-
let result_list = result.to_listview();
57+
let result_list = result
58+
.execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
59+
.unwrap();
5560

5661
assert_eq!(result_list.len(), 2, "Wrong number of filtered lists");
5762

@@ -66,7 +71,6 @@ fn test_filter_preserves_unreferenced_elements() {
6671
assert_eq!(result_list.offset_at(1), 0, "Wrong offset at index 3");
6772
}
6873

69-
#[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `filter`"]
7074
#[test]
7175
fn test_filter_with_gaps() {
7276
// ListView-specific: Test filtering with gaps in elements array.
@@ -82,8 +86,9 @@ fn test_filter_with_gaps() {
8286
// Filter to keep lists with gaps and overlaps.
8387
let mask = Mask::from_iter([false, true, true, true, false]);
8488
let result = listview.filter(mask).unwrap();
85-
#[expect(deprecated)]
86-
let result_list = result.to_listview();
89+
let result_list = result
90+
.execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
91+
.unwrap();
8792

8893
assert_eq!(result_list.len(), 3, "Wrong filter result length");
8994

@@ -105,7 +110,6 @@ fn test_filter_with_gaps() {
105110
);
106111
}
107112

108-
#[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `filter`"]
109113
#[test]
110114
fn test_filter_constant_arrays() {
111115
// ListView-specific: Test filter with ConstantArray for offsets/sizes.
@@ -126,8 +130,9 @@ fn test_filter_constant_arrays() {
126130

127131
let mask1 = Mask::from_iter([true, false, true, false]);
128132
let result1 = const_offset_list.filter(mask1).unwrap();
129-
#[expect(deprecated)]
130-
let result1_list = result1.to_listview();
133+
let result1_list = result1
134+
.execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
135+
.unwrap();
131136

132137
assert_eq!(result1_list.len(), 2);
133138
assert_eq!(result1_list.offset_at(0), 2); // Both offsets are 2
@@ -150,8 +155,9 @@ fn test_filter_constant_arrays() {
150155

151156
let mask2 = Mask::from_iter([true, false, true]);
152157
let result2 = both_const_list.filter(mask2).unwrap();
153-
#[expect(deprecated)]
154-
let result2_list = result2.to_listview();
158+
let result2_list = result2
159+
.execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
160+
.unwrap();
155161

156162
assert_eq!(result2_list.len(), 2);
157163
assert_eq!(result2_list.offset_at(0), 1);
@@ -160,7 +166,6 @@ fn test_filter_constant_arrays() {
160166
assert_eq!(result2_list.size_at(1), 3);
161167
}
162168

163-
#[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `filter`"]
164169
#[test]
165170
fn test_filter_extreme_offsets() {
166171
// ListView-specific: Test with very large offsets.
@@ -176,8 +181,9 @@ fn test_filter_extreme_offsets() {
176181
// Filter to keep only 2 lists, demonstrating we keep all 10000 elements.
177182
let mask = Mask::from_iter([false, true, false, false, true]);
178183
let result = listview.filter(mask).unwrap();
179-
#[expect(deprecated)]
180-
let result_list = result.to_listview();
184+
let result_list = result
185+
.execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
186+
.unwrap();
181187

182188
assert_eq!(result_list.len(), 2);
183189

@@ -212,8 +218,9 @@ fn test_filter_extreme_offsets() {
212218
// Test sparse selection from large dataset.
213219
let sparse_mask = Mask::from_iter((0..5).map(|i| i == 0 || i == 4));
214220
let sparse_result = listview.filter(sparse_mask).unwrap();
215-
#[expect(deprecated)]
216-
let sparse_list = sparse_result.to_listview();
221+
let sparse_list = sparse_result
222+
.execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
223+
.unwrap();
217224

218225
assert_eq!(sparse_list.len(), 2);
219226
assert_eq!(sparse_list.offset_at(0), 0); // First list

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

Lines changed: 22 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,11 @@
11
// SPDX-License-Identifier: Apache-2.0
22
// SPDX-FileCopyrightText: Copyright the Vortex contributors
33

4+
use std::sync::LazyLock;
5+
46
use rstest::rstest;
57
use vortex_buffer::buffer;
8+
use vortex_session::VortexSession;
69

710
use super::common::create_basic_listview;
811
use super::common::create_empty_lists_listview;
@@ -11,17 +14,19 @@ use super::common::create_nullable_listview;
1114
use super::common::create_overlapping_listview;
1215
use crate::IntoArray;
1316
use crate::LEGACY_SESSION;
14-
#[expect(deprecated)]
15-
use crate::ToCanonical as _;
1617
use crate::VortexSessionExecute;
1718
use crate::arrays::ConstantArray;
1819
use crate::arrays::ListViewArray;
1920
use crate::arrays::PrimitiveArray;
2021
use crate::arrays::listview::ListViewArrayExt;
2122
use crate::assert_arrays_eq;
2223
use crate::compute::conformance::take::test_take_conformance;
24+
use crate::session::ArraySession;
2325
use crate::validity::Validity;
2426

27+
static SESSION: LazyLock<VortexSession> =
28+
LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
29+
2530
// Conformance tests for common take scenarios.
2631
#[rstest]
2732
#[case::basic(create_basic_listview())]
@@ -35,7 +40,6 @@ fn test_take_listview_conformance(#[case] listview: ListViewArray) {
3540

3641
// ListView-specific tests that aren't covered by conformance.
3742

38-
#[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `take`"]
3943
#[test]
4044
fn test_take_preserves_unreferenced_elements() {
4145
// ListView-specific: Test that take preserves the entire elements array
@@ -49,8 +53,9 @@ fn test_take_preserves_unreferenced_elements() {
4953
// Take only 2 lists.
5054
let indices = buffer![1u32, 3].into_array();
5155
let result = listview.take(indices).unwrap();
52-
#[expect(deprecated)]
53-
let result_list = result.to_listview();
56+
let result_list = result
57+
.execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
58+
.unwrap();
5459

5560
assert_eq!(result_list.len(), 2);
5661

@@ -65,7 +70,6 @@ fn test_take_preserves_unreferenced_elements() {
6570
assert_eq!(result_list.offset_at(1), 0); // List 3
6671
}
6772

68-
#[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `take`"]
6973
#[test]
7074
fn test_take_with_gaps() {
7175
// ListView-specific: Test with gaps in elements array.
@@ -78,8 +82,9 @@ fn test_take_with_gaps() {
7882

7983
let indices = buffer![1u32, 3, 4, 2].into_array();
8084
let result = listview.take(indices).unwrap();
81-
#[expect(deprecated)]
82-
let result_list = result.to_listview();
85+
let result_list = result
86+
.execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
87+
.unwrap();
8388

8489
// Verify the entire elements array is preserved including gaps.
8590
assert_arrays_eq!(
@@ -94,7 +99,6 @@ fn test_take_with_gaps() {
9499
);
95100
}
96101

97-
#[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `take`"]
98102
#[test]
99103
fn test_take_constant_arrays() {
100104
// ListView-specific: Test with ConstantArray for offsets/sizes.
@@ -114,8 +118,9 @@ fn test_take_constant_arrays() {
114118

115119
let indices = buffer![3u32, 0, 2].into_array();
116120
let result = const_offset_list.take(indices).unwrap();
117-
#[expect(deprecated)]
118-
let result_list = result.to_listview();
121+
let result_list = result
122+
.execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
123+
.unwrap();
119124

120125
assert_eq!(result_list.len(), 3);
121126
assert_eq!(result_list.offset_at(0), 2); // All offsets are 2
@@ -139,8 +144,9 @@ fn test_take_constant_arrays() {
139144

140145
let indices2 = buffer![2u32, 0].into_array();
141146
let result2 = both_const_list.take(indices2).unwrap();
142-
#[expect(deprecated)]
143-
let result2_list = result2.to_listview();
147+
let result2_list = result2
148+
.execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
149+
.unwrap();
144150

145151
assert_eq!(result2_list.len(), 2);
146152
assert_eq!(result2_list.offset_at(0), 1);
@@ -149,7 +155,6 @@ fn test_take_constant_arrays() {
149155
assert_eq!(result2_list.size_at(1), 3);
150156
}
151157

152-
#[ignore = "TODO(connor)[ListView]: Don't rebuild ListView after every `take`"]
153158
#[test]
154159
fn test_take_extreme_offsets() {
155160
// ListView-specific: Test with very large offsets to demonstrate
@@ -165,8 +170,9 @@ fn test_take_extreme_offsets() {
165170
// Take only 2 lists, demonstrating we keep all 10000 elements.
166171
let indices = buffer![1u32, 4].into_array();
167172
let result = listview.take(indices).unwrap();
168-
#[expect(deprecated)]
169-
let result_list = result.to_listview();
173+
let result_list = result
174+
.execute::<ListViewArray>(&mut SESSION.create_execution_ctx())
175+
.unwrap();
170176

171177
assert_eq!(result_list.len(), 2);
172178

0 commit comments

Comments
 (0)