vortex_mask/
eq.rs

1// SPDX-License-Identifier: Apache-2.0
2// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4use std::mem;
5
6use crate::Mask;
7
8impl PartialEq for Mask {
9    #[inline]
10    fn eq(&self, other: &Self) -> bool {
11        if self.len() != other.len() {
12            return false;
13        }
14        if mem::discriminant(self) == mem::discriminant(other) && !matches!(self, Mask::Values(_)) {
15            return true;
16        }
17        if self.true_count() != other.true_count() {
18            return false;
19        }
20
21        // TODO(ngates): we could compare by indices if density is low enough
22        self.bit_buffer() == other.bit_buffer()
23    }
24}
25
26impl Eq for Mask {}
27
28#[cfg(test)]
29mod test {
30    use vortex_buffer::BitBuffer;
31
32    use crate::Mask;
33
34    #[test]
35    fn filter_mask_eq() {
36        assert_eq!(Mask::new_true(5), Mask::from_buffer(BitBuffer::new_set(5)));
37        assert_eq!(
38            Mask::new_false(5),
39            Mask::from_buffer(BitBuffer::new_unset(5))
40        );
41        assert_eq!(
42            Mask::from_indices(5, vec![0, 2, 3]),
43            Mask::from_slices(5, vec![(0, 1), (2, 4)])
44        );
45        assert_eq!(
46            Mask::from_indices(5, vec![0, 2, 3]),
47            Mask::from_buffer(BitBuffer::from_iter([true, false, true, true, false]))
48        );
49    }
50
51    #[test]
52    fn test_mask_eq_different_lengths() {
53        let mask1 = Mask::new_true(5);
54        let mask2 = Mask::new_true(3);
55        assert_ne!(mask1, mask2);
56    }
57
58    #[test]
59    fn test_mask_eq_different_true_counts() {
60        let mask1 = Mask::from_buffer(BitBuffer::from_iter([true, true, false]));
61        let mask2 = Mask::from_buffer(BitBuffer::from_iter([true, false, false]));
62        assert_ne!(mask1, mask2);
63    }
64
65    #[test]
66    fn test_mask_eq_same_count_different_positions() {
67        let mask1 = Mask::from_buffer(BitBuffer::from_iter([true, false, false]));
68        let mask2 = Mask::from_buffer(BitBuffer::from_iter([false, true, false]));
69        assert_ne!(mask1, mask2);
70    }
71
72    #[test]
73    fn test_mask_eq_all_variants() {
74        // Test AllTrue == AllTrue
75        let all_true1 = Mask::new_true(5);
76        let all_true2 = Mask::new_true(5);
77        assert_eq!(all_true1, all_true2);
78
79        // Test AllFalse == AllFalse
80        let all_false1 = Mask::new_false(5);
81        let all_false2 = Mask::new_false(5);
82        assert_eq!(all_false1, all_false2);
83
84        // Test AllTrue != AllFalse
85        assert_ne!(all_true1, all_false1);
86
87        // Test Values == Values
88        let values1 = Mask::from_buffer(BitBuffer::from_iter([true, false, true]));
89        let values2 = Mask::from_buffer(BitBuffer::from_iter([true, false, true]));
90        assert_eq!(values1, values2);
91
92        // Test AllTrue != Values (even if all values are true)
93        let all_true_values = Mask::from_buffer(BitBuffer::new_set(5));
94        assert_eq!(all_true1, all_true_values); // They should be equal
95
96        // Test AllFalse != Values (even if all values are false)
97        let all_false_values = Mask::from_buffer(BitBuffer::new_unset(5));
98        assert_eq!(all_false1, all_false_values); // They should be equal
99    }
100
101    #[test]
102    fn test_mask_eq_symmetric() {
103        // Test that if a == b then b == a
104        let mask1 = Mask::from_indices(5, vec![0, 2, 4]);
105        let mask2 = Mask::from_slices(5, vec![(0, 1), (2, 3), (4, 5)]);
106        assert_eq!(mask1, mask2);
107        assert_eq!(mask2, mask1);
108    }
109
110    #[test]
111    fn test_mask_eq_transitive() {
112        // Test that if a == b and b == c then a == c
113        let mask1 = Mask::from_indices(5, vec![1, 3]);
114        let mask2 = Mask::from_slices(5, vec![(1, 2), (3, 4)]);
115        let mask3 = Mask::from_buffer(BitBuffer::from_iter([false, true, false, true, false]));
116
117        assert_eq!(mask1, mask2);
118        assert_eq!(mask2, mask3);
119        assert_eq!(mask1, mask3);
120    }
121
122    #[test]
123    fn test_mask_eq_empty() {
124        // All empty masks become AllFalse regardless of input type
125        let empty1 = Mask::new_true(0);
126        let empty2 = Mask::new_false(0);
127        let empty3 = Mask::from_buffer(BitBuffer::new_set(0));
128        let empty4 = Mask::from_buffer(BitBuffer::new_unset(0));
129
130        // All should be AllFalse(0) when created from buffer
131        assert!(matches!(empty3, Mask::AllFalse(0)));
132        assert!(matches!(empty4, Mask::AllFalse(0)));
133
134        // new_true(0) is AllTrue(0), new_false(0) is AllFalse(0)
135        assert!(matches!(empty1, Mask::AllTrue(0)));
136        assert!(matches!(empty2, Mask::AllFalse(0)));
137    }
138
139    #[test]
140    fn test_mask_eq_different_representations() {
141        // Test that masks with the same logical values but different internal representations are equal
142        let indices = vec![0, 1, 2, 5, 6, 9];
143        let slices = vec![(0, 3), (5, 7), (9, 10)];
144        let buffer = BitBuffer::from_iter([
145            true, true, true, false, false, true, true, false, false, true,
146        ]);
147
148        let mask1 = Mask::from_indices(10, indices);
149        let mask2 = Mask::from_slices(10, slices);
150        let mask3 = Mask::from_buffer(buffer);
151
152        assert_eq!(mask1, mask2);
153        assert_eq!(mask2, mask3);
154        assert_eq!(mask1, mask3);
155    }
156}
vortex_mask/eq.rs

vortex_mask/
eq.rs
