Skip to content

Commit 0d58c91

Browse files
a10ya10y
committed
unit tests
Signed-off-by: Andrew Duffy <andrew@a10y.dev>
1 parent c77f2d2 commit 0d58c91

File tree

15 files changed

+724
-1
lines changed

15 files changed

+724
-1
lines changed

‎vortex-compute/src/filter/mod.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -40,7 +40,7 @@ impl<'a> MaskIndices<'a> {
4040
/// # Safety
4141
///
4242
/// The caller must ensure that the indices are strict-sorted, i.e. that they
43-
/// are montonic and unique.
43+
/// are monotonic and unique.
4444
///
4545
/// Users of the `Indices` type assume this and failure to uphold this guarantee
4646
/// can result in UB downstream.

‎vortex-compute/src/filter/vector/binaryview.rs‎

Lines changed: 172 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -42,3 +42,175 @@ where
4242
}
4343
}
4444
}
45+
46+
#[cfg(test)]
47+
mod tests {
48+
use vortex_mask::Mask;
49+
use vortex_vector::binaryview::StringVectorMut;
50+
use vortex_vector::{VectorMutOps, VectorOps};
51+
52+
use super::*;
53+
use crate::filter::MaskIndices;
54+
55+
#[test]
56+
fn test_filter_binary_view_vector_with_mask() {
57+
let mut vec = StringVectorMut::with_capacity(5);
58+
vec.append_values("hello", 1);
59+
vec.append_values("world", 1);
60+
vec.append_values("foo", 1);
61+
vec.append_values("bar", 1);
62+
vec.append_values("baz", 1);
63+
let vec = vec.freeze();
64+
65+
let mask = Mask::from_iter([true, false, true, false, true]);
66+
67+
let filtered = vec.filter(&mask);
68+
69+
assert_eq!(filtered.len(), 3);
70+
assert_eq!(filtered.validity().true_count(), 3);
71+
assert_eq!(filtered.get_ref(0), Some("hello"));
72+
assert_eq!(filtered.get_ref(1), Some("foo"));
73+
assert_eq!(filtered.get_ref(2), Some("baz"));
74+
}
75+
76+
#[test]
77+
fn test_filter_binary_view_vector_with_mask_indices() {
78+
let mut vec = StringVectorMut::with_capacity(5);
79+
vec.append_values("hello", 1);
80+
vec.append_values("world", 1);
81+
vec.append_values("foo", 1);
82+
vec.append_values("bar", 1);
83+
vec.append_values("baz", 1);
84+
let vec = vec.freeze();
85+
86+
let indices = unsafe { MaskIndices::new_unchecked(&[0, 2, 4]) };
87+
88+
let filtered = vec.filter(&indices);
89+
90+
assert_eq!(filtered.len(), 3);
91+
assert_eq!(filtered.validity().true_count(), 3);
92+
assert_eq!(filtered.get_ref(0), Some("hello"));
93+
assert_eq!(filtered.get_ref(1), Some("foo"));
94+
assert_eq!(filtered.get_ref(2), Some("baz"));
95+
}
96+
97+
#[test]
98+
fn test_filter_binary_view_vector_with_nulls() {
99+
let mut vec = StringVectorMut::with_capacity(5);
100+
vec.append_values("hello", 1);
101+
vec.append_nulls(1);
102+
vec.append_values("foo", 1);
103+
vec.append_values("bar", 1);
104+
vec.append_nulls(1);
105+
let vec = vec.freeze();
106+
107+
let mask = Mask::from_iter([true, true, false, true, false]);
108+
109+
let filtered = vec.filter(&mask);
110+
111+
assert_eq!(filtered.len(), 3);
112+
assert_eq!(filtered.validity().true_count(), 2);
113+
assert_eq!(filtered.get_ref(0), Some("hello"));
114+
assert_eq!(filtered.get_ref(1), None);
115+
assert_eq!(filtered.get_ref(2), Some("bar"));
116+
}
117+
118+
#[test]
119+
fn test_filter_binary_view_vector_all_true() {
120+
let mut vec = StringVectorMut::with_capacity(3);
121+
vec.append_values("hello", 1);
122+
vec.append_values("world", 1);
123+
vec.append_values("foo", 1);
124+
let vec = vec.freeze();
125+
126+
let mask = Mask::new_true(3);
127+
128+
let filtered = vec.filter(&mask);
129+
130+
assert_eq!(filtered.len(), 3);
131+
assert_eq!(filtered.get_ref(0), Some("hello"));
132+
assert_eq!(filtered.get_ref(1), Some("world"));
133+
assert_eq!(filtered.get_ref(2), Some("foo"));
134+
}
135+
136+
#[test]
137+
fn test_filter_binary_view_vector_all_false() {
138+
let mut vec = StringVectorMut::with_capacity(3);
139+
vec.append_values("hello", 1);
140+
vec.append_values("world", 1);
141+
vec.append_values("foo", 1);
142+
let vec = vec.freeze();
143+
144+
let mask = Mask::new_false(3);
145+
146+
let filtered = vec.filter(&mask);
147+
148+
assert_eq!(filtered.len(), 0);
149+
}
150+
151+
#[test]
152+
fn test_filter_binary_view_vector_mut_with_mask() {
153+
let mut vec = StringVectorMut::with_capacity(5);
154+
vec.append_values("hello", 1);
155+
vec.append_values("world", 1);
156+
vec.append_values("foo", 1);
157+
vec.append_values("bar", 1);
158+
vec.append_values("baz", 1);
159+
160+
let mask = Mask::from_iter([true, false, true, false, true]);
161+
162+
vec.filter(&mask);
163+
164+
assert_eq!(vec.len(), 3);
165+
let frozen = vec.freeze();
166+
assert_eq!(frozen.len(), 3);
167+
assert_eq!(frozen.validity().true_count(), 3);
168+
assert_eq!(frozen.get_ref(0), Some("hello"));
169+
assert_eq!(frozen.get_ref(1), Some("foo"));
170+
assert_eq!(frozen.get_ref(2), Some("baz"));
171+
}
172+
173+
#[test]
174+
fn test_filter_binary_view_vector_mut_with_mask_indices() {
175+
let mut vec = StringVectorMut::with_capacity(5);
176+
vec.append_values("hello", 1);
177+
vec.append_values("world", 1);
178+
vec.append_values("foo", 1);
179+
vec.append_values("bar", 1);
180+
vec.append_values("baz", 1);
181+
182+
let indices = unsafe { MaskIndices::new_unchecked(&[0, 2, 4]) };
183+
184+
vec.filter(&indices);
185+
186+
assert_eq!(vec.len(), 3);
187+
let frozen = vec.freeze();
188+
assert_eq!(frozen.len(), 3);
189+
assert_eq!(frozen.validity().true_count(), 3);
190+
assert_eq!(frozen.get_ref(0), Some("hello"));
191+
assert_eq!(frozen.get_ref(1), Some("foo"));
192+
assert_eq!(frozen.get_ref(2), Some("baz"));
193+
}
194+
195+
#[test]
196+
fn test_filter_binary_view_vector_mut_with_nulls() {
197+
let mut vec = StringVectorMut::with_capacity(5);
198+
vec.append_values("hello", 1);
199+
vec.append_nulls(1);
200+
vec.append_values("foo", 1);
201+
vec.append_values("bar", 1);
202+
vec.append_nulls(1);
203+
204+
let mask = Mask::from_iter([true, true, false, true, false]);
205+
206+
vec.filter(&mask);
207+
208+
assert_eq!(vec.len(), 3);
209+
let frozen = vec.freeze();
210+
assert_eq!(frozen.len(), 3);
211+
assert_eq!(frozen.validity().true_count(), 2);
212+
assert_eq!(frozen.get_ref(0), Some("hello"));
213+
assert_eq!(frozen.get_ref(1), None);
214+
assert_eq!(frozen.get_ref(2), Some("bar"));
215+
}
216+
}

‎vortex-compute/src/filter/vector/bool.rs‎

Lines changed: 113 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -42,3 +42,116 @@ where
4242
}
4343
}
4444
}
45+
46+
#[cfg(test)]
47+
mod tests {
48+
use vortex_buffer::BitBuffer;
49+
use vortex_mask::Mask;
50+
use vortex_vector::bool::BoolVectorMut;
51+
use vortex_vector::{VectorMutOps, VectorOps};
52+
53+
use super::*;
54+
use crate::filter::MaskIndices;
55+
56+
#[test]
57+
fn test_filter_bool_vector_with_mask() {
58+
let vec = BoolVectorMut::from_iter([true, false, true, false, true]).freeze();
59+
let mask = Mask::from_iter([true, false, true, false, true]);
60+
61+
let filtered = vec.filter(&mask);
62+
63+
assert_eq!(filtered.len(), 3);
64+
assert_eq!(filtered.validity().true_count(), 3);
65+
assert_eq!(filtered.bits(), &BitBuffer::from_iter([true, true, true]));
66+
}
67+
68+
#[test]
69+
fn test_filter_bool_vector_with_mask_indices() {
70+
let vec = BoolVectorMut::from_iter([true, false, true, false, true]).freeze();
71+
let indices = unsafe { MaskIndices::new_unchecked(&[0, 2, 4]) };
72+
73+
let filtered = vec.filter(&indices);
74+
75+
assert_eq!(filtered.len(), 3);
76+
assert_eq!(filtered.validity().true_count(), 3);
77+
assert_eq!(filtered.bits(), &BitBuffer::from_iter([true, true, true]));
78+
}
79+
80+
#[test]
81+
fn test_filter_bool_vector_with_nulls() {
82+
let vec =
83+
BoolVectorMut::from_iter([Some(true), None, Some(false), Some(true), None]).freeze();
84+
let mask = Mask::from_iter([true, true, false, true, false]);
85+
86+
let filtered = vec.filter(&mask);
87+
88+
assert_eq!(filtered.len(), 3);
89+
assert_eq!(filtered.validity().true_count(), 2);
90+
91+
assert_eq!(
92+
filtered.validity().to_bit_buffer(),
93+
BitBuffer::from_iter([true, false, true])
94+
);
95+
assert_eq!(filtered.bits(), &BitBuffer::from_iter([true, false, true]));
96+
}
97+
98+
#[test]
99+
fn test_filter_bool_vector_all_true() {
100+
let vec = BoolVectorMut::from_iter([true, false, true]).freeze();
101+
let mask = Mask::new_true(3);
102+
103+
let filtered = vec.filter(&mask);
104+
105+
assert_eq!(filtered.len(), 3);
106+
assert_eq!(filtered.bits(), &BitBuffer::from_iter([true, false, true]));
107+
}
108+
109+
#[test]
110+
fn test_filter_bool_vector_all_false() {
111+
let vec = BoolVectorMut::from_iter([true, false, true]).freeze();
112+
let mask = Mask::new_false(3);
113+
114+
let filtered = vec.filter(&mask);
115+
116+
assert_eq!(filtered.len(), 0);
117+
}
118+
119+
#[test]
120+
fn test_filter_bool_vector_mut_with_mask() {
121+
let mut vec = BoolVectorMut::from_iter([true, false, true, false, true]);
122+
let mask = Mask::from_iter([true, false, true, false, true]);
123+
124+
vec.filter(&mask);
125+
126+
assert_eq!(vec.len(), 3);
127+
let frozen = vec.freeze();
128+
assert_eq!(frozen.len(), 3);
129+
assert_eq!(frozen.validity().true_count(), 3);
130+
}
131+
132+
#[test]
133+
fn test_filter_bool_vector_mut_with_mask_indices() {
134+
let mut vec = BoolVectorMut::from_iter([true, false, true, false, true]);
135+
let indices = unsafe { MaskIndices::new_unchecked(&[0, 2, 4]) };
136+
137+
vec.filter(&indices);
138+
139+
assert_eq!(vec.len(), 3);
140+
let frozen = vec.freeze();
141+
assert_eq!(frozen.len(), 3);
142+
assert_eq!(frozen.validity().true_count(), 3);
143+
}
144+
145+
#[test]
146+
fn test_filter_bool_vector_mut_with_nulls() {
147+
let mut vec = BoolVectorMut::from_iter([Some(true), None, Some(false), Some(true), None]);
148+
let mask = Mask::from_iter([true, true, false, true, false]);
149+
150+
vec.filter(&mask);
151+
152+
assert_eq!(vec.len(), 3);
153+
let frozen = vec.freeze();
154+
assert_eq!(frozen.len(), 3);
155+
assert_eq!(frozen.validity().true_count(), 2);
156+
}
157+
}

0 commit comments

Comments
 (0)