From d4c10399d85fe67ee02f4ad75dc47dea51c1dcff Mon Sep 17 00:00:00 2001 From: Mikhail Kot Date: Tue, 3 Nov 2026 17:34:24 +0000 Subject: [PATCH 1/2] Property-based tests for Mask Signed-off-by: Mikhail Kot --- Cargo.lock | 1 + vortex-mask/Cargo.toml | 1 + vortex-mask/src/bitops.rs | 318 --------- vortex-mask/src/eq.rs | 133 +--- vortex-mask/src/intersect_by_rank/mod.rs | 133 ---- vortex-mask/src/tests.rs | 823 ++++++++--------------- 6 files changed, 293 insertions(+), 1116 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index efd8fcf1a69..b85cdd5ad32 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -12264,6 +12264,7 @@ name = "vortex-mask" version = "0.1.0" dependencies = [ "codspeed-divan-compat", + "hegeltest", "itertools 0.14.0", "mimalloc", "rand 0.10.3", diff --git a/vortex-mask/Cargo.toml b/vortex-mask/Cargo.toml index c0f1f5fb218..58ee17dc7fe 100644 --- a/vortex-mask/Cargo.toml +++ b/vortex-mask/Cargo.toml @@ -26,6 +26,7 @@ vortex-error = { workspace = true } [dev-dependencies] divan = { workspace = true } +hegeltest = { workspace = true } mimalloc = { workspace = true } rand = { workspace = true } rstest = { workspace = true } diff --git a/vortex-mask/src/bitops.rs b/vortex-mask/src/bitops.rs index e795c57204f..3fac559f3ac 100644 --- a/vortex-mask/src/bitops.rs +++ b/vortex-mask/src/bitops.rs @@ -122,321 +122,3 @@ impl Not for &Mask { } } } - -#[cfg(test)] -#[expect(clippy::many_single_char_names)] -mod tests { - use vortex_buffer::BitBuffer; - - use super::*; - - #[test] - fn test_bitand_all_combinations() { - let len = 5; - - // Test AllTrue & AllTrue - let all_true = Mask::new_true(len); - let result = &all_true & &all_true; - assert!(result.all_true()); - assert_eq!(result.true_count(), len); - - // Test AllTrue & AllFalse - let all_false = Mask::new_false(len); - let result = &all_true & &all_false; - assert!(result.all_false()); - assert_eq!(result.true_count(), 0); - - // Test AllFalse & AllTrue - let result = &all_false & &all_true; - assert!(result.all_false()); - assert_eq!(result.true_count(), 0); - - // Test AllFalse & AllFalse - let result = &all_false & &all_false; - assert!(result.all_false()); - assert_eq!(result.true_count(), 0); - } - - #[test] - fn test_bitand_with_values() { - let mask1 = Mask::from_buffer(BitBuffer::from_iter([true, false, true, false, true])); - let mask2 = Mask::from_buffer(BitBuffer::from_iter([true, true, false, false, true])); - - let result = &mask1 & &mask2; - assert_eq!(result.len(), 5); - assert_eq!(result.true_count(), 2); - assert!(result.value(0)); // true & true = true - assert!(!result.value(1)); // false & true = false - assert!(!result.value(2)); // true & false = false - assert!(!result.value(3)); // false & false = false - assert!(result.value(4)); // true & true = true - } - - #[test] - fn test_bitand_all_true_with_values() { - let all_true = Mask::new_true(5); - let values = Mask::from_buffer(BitBuffer::from_iter([true, false, true, false, true])); - - // AllTrue & Values should return Values - let result = &all_true & &values; - assert_eq!(result.true_count(), 3); - assert_eq!(result.len(), 5); - assert!(result.value(0)); - assert!(!result.value(1)); - assert!(result.value(2)); - assert!(!result.value(3)); - assert!(result.value(4)); - } - - #[test] - fn test_bitand_all_false_with_values() { - let all_false = Mask::new_false(5); - let values = Mask::from_buffer(BitBuffer::from_iter([true, false, true, false, true])); - - // AllFalse & Values should return AllFalse - let result = &all_false & &values; - assert!(result.all_false()); - assert_eq!(result.true_count(), 0); - } - - #[test] - fn test_bitand_values_with_all_true() { - let values = Mask::from_buffer(BitBuffer::from_iter([true, false, true, false, true])); - let all_true = Mask::new_true(5); - - // Values & AllTrue should return Values - let result = &values & &all_true; - assert_eq!(result.true_count(), 3); - assert_eq!(result.len(), 5); - assert!(result.value(0)); - assert!(!result.value(1)); - assert!(result.value(2)); - assert!(!result.value(3)); - assert!(result.value(4)); - } - - #[test] - fn test_bitand_values_with_all_false() { - let values = Mask::from_buffer(BitBuffer::from_iter([true, false, true, false, true])); - let all_false = Mask::new_false(5); - - // Values & AllFalse should return AllFalse - let result = &values & &all_false; - assert!(result.all_false()); - assert_eq!(result.true_count(), 0); - } - - #[test] - fn test_bitand_empty_masks() { - let empty1 = Mask::new_true(0); - let empty2 = Mask::new_false(0); - - let result = &empty1 & &empty2; - assert_eq!(result.len(), 0); - assert!(result.is_empty()); - } - - #[test] - #[should_panic(expected = "Masks must have the same length")] - fn test_bitand_different_lengths() { - let mask1 = Mask::new_true(5); - let mask2 = Mask::new_true(3); - let _unused = &mask1 & &mask2; - } - - #[test] - fn test_not_all_true() { - let all_true = Mask::new_true(5); - let result = !&all_true; - assert!(result.all_false()); - assert_eq!(result.true_count(), 0); - assert_eq!(result.len(), 5); - } - - #[test] - fn test_not_all_false() { - let all_false = Mask::new_false(5); - let result = !&all_false; - assert!(result.all_true()); - assert_eq!(result.true_count(), 5); - assert_eq!(result.len(), 5); - } - - #[test] - fn test_not_values() { - let values = Mask::from_buffer(BitBuffer::from_iter([true, false, true, false, true])); - let result = !&values; - - assert_eq!(result.len(), 5); - assert_eq!(result.true_count(), 2); - assert!(!result.value(0)); // !true = false - assert!(result.value(1)); // !false = true - assert!(!result.value(2)); // !true = false - assert!(result.value(3)); // !false = true - assert!(!result.value(4)); // !true = false - } - - #[test] - fn test_not_empty() { - let empty_true = Mask::new_true(0); - let result = !&empty_true; - assert_eq!(result.len(), 0); - assert!(result.is_empty()); - - let empty_false = Mask::new_false(0); - let result = !&empty_false; - assert_eq!(result.len(), 0); - assert!(result.is_empty()); - } - - #[test] - fn test_double_not() { - let original = Mask::from_buffer(BitBuffer::from_iter([true, false, true, false, true])); - let double_not = !&(!&original); - - // Double negation should return the original - assert_eq!(double_not.true_count(), original.true_count()); - for i in 0..5 { - assert_eq!(double_not.value(i), original.value(i)); - } - } - - #[test] - fn test_demorgan_law() { - // Test De Morgan's law: !(A & B) = !A | !B - let a = Mask::from_buffer(BitBuffer::from_iter([true, true, false, false])); - let b = Mask::from_buffer(BitBuffer::from_iter([true, false, true, false])); - - let and_result = &a & &b; - let not_and = !&and_result; - - let not_a = !&a; - let not_b = !&b; - let or_result = ¬_a | ¬_b; - - assert_eq!(not_and.len(), 4); - assert!(!not_and.value(0)); // !(true & true) = false - assert!(not_and.value(1)); // !(true & false) = true - assert!(not_and.value(2)); // !(false & true) = true - assert!(not_and.value(3)); // !(false & false) = true - - assert_eq!(or_result.len(), 4); - assert_eq!(or_result, not_and) - } - - #[test] - fn test_bitand_associativity() { - // Test (A & B) & C = A & (B & C) - let a = Mask::from_buffer(BitBuffer::from_iter([true, true, false, true])); - let b = Mask::from_buffer(BitBuffer::from_iter([true, false, true, true])); - let c = Mask::from_buffer(BitBuffer::from_iter([false, true, true, true])); - - let left_assoc = &(&a & &b) & &c; - let right_assoc = &a & &(&b & &c); - - assert_eq!(left_assoc.true_count(), right_assoc.true_count()); - for i in 0..4 { - assert_eq!(left_assoc.value(i), right_assoc.value(i)); - } - } - - #[test] - fn test_bitand_commutativity() { - // Test A & B = B & A - let a = Mask::from_buffer(BitBuffer::from_iter([true, false, true, false])); - let b = Mask::from_buffer(BitBuffer::from_iter([false, true, false, true])); - - let a_and_b = &a & &b; - let b_and_a = &b & &a; - - assert_eq!(a_and_b.true_count(), b_and_a.true_count()); - for i in 0..4 { - assert_eq!(a_and_b.value(i), b_and_a.value(i)); - } - } - - #[test] - fn test_bitand_idempotence() { - // Test A & A = A - let mask = Mask::from_buffer(BitBuffer::from_iter([true, false, true, false, true])); - let result = &mask & &mask; - - assert_eq!(result.true_count(), mask.true_count()); - for i in 0..5 { - assert_eq!(result.value(i), mask.value(i)); - } - } - - #[test] - fn test_complex_expression() { - // Test a more complex expression: (!(!A) | B) & !C - let a = Mask::from_buffer(BitBuffer::from_iter([true, false, true, false])); - let b = Mask::from_buffer(BitBuffer::from_iter([true, true, false, false])); - let c = Mask::from_buffer(BitBuffer::from_iter([false, true, false, true])); - - let not_not_a = !(&(!&a)); - let not_not_a_or_b = ¬_not_a | &b; - let not_c = !&c; - let result = ¬_not_a_or_b & ¬_c; - - // Verify the result manually - assert!(result.value(0)); // (!(!true) | true) & !false = (true | true) & true = true - assert!(!result.value(1)); // (!(!false) | true) & !true = (false | true) & false = false - assert!(result.value(2)); // (!(!true) | false) & !false = (true | false) & true = true - assert!(!result.value(3)); // (!(!false) | false) & !true = (false | false) & false = false - } - - #[test] - fn test_bitand_not() { - let a = Mask::from_buffer(BitBuffer::from_iter([true, true, false, false])); - let b = Mask::from_buffer(BitBuffer::from_iter([true, false, true, false])); - let result = a.clone().bitand_not(&b); - assert!(!result.value(0)); // true & !true = false - assert!(result.value(1)); // true & !false = true - assert!(!result.value(2)); // false & !true = false - assert!(!result.value(3)); // false & !false = false - - // bitand_not(All) = None - assert!(a.clone().bitand_not(&Mask::new_true(4)).all_false()); - - // bitand_not(None) = self - let none = Mask::new_false(4); - assert_eq!(a.clone().bitand_not(&none), a); - - // None.bitand_not(_) = None - assert!(none.bitand_not(&a).all_false()); - - // All.bitand_not(x) = !x - let not_b = !&b; - let all_bitand_not_b = Mask::new_true(4).bitand_not(&b); - for i in 0..4 { - assert_eq!(all_bitand_not_b.value(i), not_b.value(i)); - } - } - - #[test] - fn test_bitor() { - // Test basic OR operations - let mask1 = Mask::from_buffer(BitBuffer::from_iter([true, false, true, false, true])); - let mask2 = Mask::from_buffer(BitBuffer::from_iter([true, true, false, false, true])); - - let result = &mask1 | &mask2; - assert_eq!(result.len(), 5); - assert_eq!(result.true_count(), 4); - assert!(result.value(0)); // true | true = true - assert!(result.value(1)); // false | true = true - assert!(result.value(2)); // true | false = true - assert!(!result.value(3)); // false | false = false - assert!(result.value(4)); // true | true = true - - // Test with AllTrue - let all_true = Mask::new_true(5); - let result = &mask1 | &all_true; - assert!(result.all_true()); - - // Test with AllFalse - let all_false = Mask::new_false(5); - let result = &mask1 | &all_false; - assert_eq!(result, mask1); - } -} diff --git a/vortex-mask/src/eq.rs b/vortex-mask/src/eq.rs index c36ead6d8fd..9ba69eb6c27 100644 --- a/vortex-mask/src/eq.rs +++ b/vortex-mask/src/eq.rs @@ -11,6 +11,9 @@ impl PartialEq for Mask { if self.len() != other.len() { return false; } + if self.is_empty() { + return true; + } if mem::discriminant(self) == mem::discriminant(other) && !matches!(self, Mask::Values(_)) { return true; } @@ -24,133 +27,3 @@ impl PartialEq for Mask { } impl Eq for Mask {} - -#[cfg(test)] -mod test { - use vortex_buffer::BitBuffer; - - use crate::Mask; - - #[test] - fn filter_mask_eq() { - assert_eq!(Mask::new_true(5), Mask::from_buffer(BitBuffer::new_set(5))); - assert_eq!( - Mask::new_false(5), - Mask::from_buffer(BitBuffer::new_unset(5)) - ); - assert_eq!( - Mask::from_indices(5, vec![0, 2, 3]), - Mask::from_slices(5, vec![(0, 1), (2, 4)]) - ); - assert_eq!( - Mask::from_indices(5, vec![0, 2, 3]), - Mask::from_buffer(BitBuffer::from_iter([true, false, true, true, false])) - ); - } - - #[test] - fn test_mask_eq_different_lengths() { - let mask1 = Mask::new_true(5); - let mask2 = Mask::new_true(3); - assert_ne!(mask1, mask2); - } - - #[test] - fn test_mask_eq_different_true_counts() { - let mask1 = Mask::from_buffer(BitBuffer::from_iter([true, true, false])); - let mask2 = Mask::from_buffer(BitBuffer::from_iter([true, false, false])); - assert_ne!(mask1, mask2); - } - - #[test] - fn test_mask_eq_same_count_different_positions() { - let mask1 = Mask::from_buffer(BitBuffer::from_iter([true, false, false])); - let mask2 = Mask::from_buffer(BitBuffer::from_iter([false, true, false])); - assert_ne!(mask1, mask2); - } - - #[test] - fn test_mask_eq_all_variants() { - // Test AllTrue == AllTrue - let all_true1 = Mask::new_true(5); - let all_true2 = Mask::new_true(5); - assert_eq!(all_true1, all_true2); - - // Test AllFalse == AllFalse - let all_false1 = Mask::new_false(5); - let all_false2 = Mask::new_false(5); - assert_eq!(all_false1, all_false2); - - // Test AllTrue != AllFalse - assert_ne!(all_true1, all_false1); - - // Test Values == Values - let values1 = Mask::from_buffer(BitBuffer::from_iter([true, false, true])); - let values2 = Mask::from_buffer(BitBuffer::from_iter([true, false, true])); - assert_eq!(values1, values2); - - // Test AllTrue != Values (even if all values are true) - let all_true_values = Mask::from_buffer(BitBuffer::new_set(5)); - assert_eq!(all_true1, all_true_values); // They should be equal - - // Test AllFalse != Values (even if all values are false) - let all_false_values = Mask::from_buffer(BitBuffer::new_unset(5)); - assert_eq!(all_false1, all_false_values); // They should be equal - } - - #[test] - fn test_mask_eq_symmetric() { - // Test that if a == b then b == a - let mask1 = Mask::from_indices(5, vec![0, 2, 4]); - let mask2 = Mask::from_slices(5, vec![(0, 1), (2, 3), (4, 5)]); - assert_eq!(mask1, mask2); - assert_eq!(mask2, mask1); - } - - #[test] - fn test_mask_eq_transitive() { - // Test that if a == b and b == c then a == c - let mask1 = Mask::from_indices(5, vec![1, 3]); - let mask2 = Mask::from_slices(5, vec![(1, 2), (3, 4)]); - let mask3 = Mask::from_buffer(BitBuffer::from_iter([false, true, false, true, false])); - - assert_eq!(mask1, mask2); - assert_eq!(mask2, mask3); - assert_eq!(mask1, mask3); - } - - #[test] - fn test_mask_eq_empty() { - // All empty masks become AllFalse regardless of input type - let empty1 = Mask::new_true(0); - let empty2 = Mask::new_false(0); - let empty3 = Mask::from_buffer(BitBuffer::new_set(0)); - let empty4 = Mask::from_buffer(BitBuffer::new_unset(0)); - - // All should be AllFalse(0) when created from buffer - assert!(matches!(empty3, Mask::AllFalse(0))); - assert!(matches!(empty4, Mask::AllFalse(0))); - - // new_true(0) is AllTrue(0), new_false(0) is AllFalse(0) - assert!(matches!(empty1, Mask::AllTrue(0))); - assert!(matches!(empty2, Mask::AllFalse(0))); - } - - #[test] - fn test_mask_eq_different_representations() { - // Test that masks with the same logical values but different internal representations are equal - let indices = vec![0, 1, 2, 5, 6, 9]; - let slices = vec![(0, 3), (5, 7), (9, 10)]; - let buffer = BitBuffer::from_iter([ - true, true, true, false, false, true, true, false, false, true, - ]); - - let mask1 = Mask::from_indices(10, indices); - let mask2 = Mask::from_slices(10, slices); - let mask3 = Mask::from_buffer(buffer); - - assert_eq!(mask1, mask2); - assert_eq!(mask2, mask3); - assert_eq!(mask1, mask3); - } -} diff --git a/vortex-mask/src/intersect_by_rank/mod.rs b/vortex-mask/src/intersect_by_rank/mod.rs index eff0f5ef2fe..1fe17f2ac8d 100644 --- a/vortex-mask/src/intersect_by_rank/mod.rs +++ b/vortex-mask/src/intersect_by_rank/mod.rs @@ -659,101 +659,6 @@ mod tests { use super::sve::Sve2Bdep; use crate::Mask; - #[test] - fn mask_bitand_all_as_bit_and() { - let this = Mask::from_buffer(BitBuffer::from_iter(vec![true, true, true, true, true])); - let mask = Mask::from_buffer(BitBuffer::from_iter(vec![false, true, false, true, true])); - assert_eq!( - this.intersect_by_rank(&mask), - Mask::from_indices(5, vec![1, 3, 4]) - ); - } - - #[test] - fn mask_bitand_all_true() { - let this = Mask::from_buffer(BitBuffer::from_iter(vec![false, false, true, true, true])); - let mask = Mask::from_buffer(BitBuffer::from_iter(vec![true, true, true])); - assert_eq!( - this.intersect_by_rank(&mask), - Mask::from_indices(5, vec![2, 3, 4]) - ); - } - - #[test] - fn mask_bitand_true() { - let this = Mask::from_buffer(BitBuffer::from_iter(vec![true, false, false, true, true])); - let mask = Mask::from_buffer(BitBuffer::from_iter(vec![true, false, true])); - assert_eq!( - this.intersect_by_rank(&mask), - Mask::from_indices(5, vec![0, 4]) - ); - } - - #[test] - fn mask_bitand_false() { - let this = Mask::from_buffer(BitBuffer::from_iter(vec![true, false, false, true, true])); - let mask = Mask::from_buffer(BitBuffer::from_iter(vec![false, false, false])); - assert_eq!(this.intersect_by_rank(&mask), Mask::from_indices(5, vec![])); - } - - #[test] - fn mask_intersect_by_rank_all_false() { - let this = Mask::AllFalse(10); - let mask = Mask::AllFalse(0); - assert_eq!(this.intersect_by_rank(&mask), Mask::AllFalse(10)); - } - - #[rstest] - #[case::all_true_with_all_true( - Mask::new_true(5), - Mask::new_true(5), - vec![0, 1, 2, 3, 4] - )] - #[case::all_true_with_all_false( - Mask::new_true(5), - Mask::new_false(5), - vec![] - )] - #[case::all_false_with_any( - Mask::new_false(10), - Mask::new_true(0), - vec![] - )] - #[case::indices_with_all_true( - Mask::from_indices(10, vec![2, 5, 7, 9]), - Mask::new_true(4), - vec![2, 5, 7, 9] - )] - #[case::indices_with_all_false( - Mask::from_indices(10, vec![2, 5, 7, 9]), - Mask::new_false(4), - vec![] - )] - fn test_intersect_by_rank_special_cases( - #[case] base_mask: Mask, - #[case] rank_mask: Mask, - #[case] expected_indices: Vec, - ) { - let result = base_mask.intersect_by_rank(&rank_mask); - assert_eq!(result.len(), base_mask.len()); - - match result.indices() { - crate::AllOr::All => assert_eq!(expected_indices.len(), result.len()), - crate::AllOr::None => assert!(expected_indices.is_empty()), - crate::AllOr::Some(indices) => assert_eq!(indices, &expected_indices[..]), - } - } - - #[test] - fn test_intersect_by_rank_example() { - // Example from the documentation - let m1 = Mask::from_iter([true, false, false, true, true, true, false, true]); - let m2 = Mask::from_iter([false, false, true, false, true]); - let result = m1.intersect_by_rank(&m2); - let expected = Mask::from_iter([false, false, false, false, true, false, false, true]); - assert_eq!(result, expected); - } - #[test] #[should_panic] fn test_intersect_by_rank_wrong_length() { @@ -762,44 +667,6 @@ mod tests { m1.intersect_by_rank(&m2); } - #[rstest] - #[case::single_element( - vec![3], - vec![true], - vec![3] - )] - #[case::single_element_masked( - vec![3], - vec![false], - vec![] - )] - #[case::alternating( - vec![0, 2, 4, 6, 8], - vec![true, false, true, false, true], - vec![0, 4, 8] - )] - #[case::consecutive( - vec![5, 6, 7, 8, 9], - vec![false, true, true, true, false], - vec![6, 7, 8] - )] - fn test_intersect_by_rank_patterns( - #[case] base_indices: Vec, - #[case] rank_pattern: Vec, - #[case] expected_indices: Vec, - ) { - let base = Mask::from_indices(10, base_indices); - let rank = Mask::from_iter(rank_pattern); - let result = base.intersect_by_rank(&rank); - assert_eq!(result.len(), base.len()); - - match result.indices() { - crate::AllOr::Some(indices) => assert_eq!(indices, &expected_indices[..]), - crate::AllOr::None => assert!(expected_indices.is_empty()), - _ => panic!("Unexpected result"), - } - } - #[rstest] // Larger sizes to push the bench-shaped buffer paths through the unit tests too. #[case::dense_len_1024(1024, 31, 0.5, 0.5)] diff --git a/vortex-mask/src/tests.rs b/vortex-mask/src/tests.rs index b888269f253..94e49c665ba 100644 --- a/vortex-mask/src/tests.rs +++ b/vortex-mask/src/tests.rs @@ -1,6 +1,8 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: Copyright the Vortex contributors +use hegel::TestCase; +use hegel::generators as gs; use rstest::rstest; use vortex_buffer::BitBuffer; @@ -8,252 +10,323 @@ use crate::AllOr; use crate::Mask; use crate::MaskIter; -// Basic mask creation and properties tests -#[test] -fn mask_all_true() { - let mask = Mask::new_true(5); - assert_eq!(mask.len(), 5); - assert_eq!(mask.true_count(), 5); - assert_eq!(mask.density(), 1.0); - assert_eq!(mask.indices(), AllOr::All); - assert_eq!(mask.slices(), AllOr::All); - assert_eq!(mask.bit_buffer(), AllOr::All,); -} +const MAX_LEN: usize = 200; -#[test] -fn mask_all_false() { - let mask = Mask::new_false(5); - assert_eq!(mask.len(), 5); - assert_eq!(mask.true_count(), 0); - assert_eq!(mask.density(), 0.0); - assert_eq!(mask.indices(), AllOr::None); - assert_eq!(mask.slices(), AllOr::None); - assert_eq!(mask.bit_buffer(), AllOr::None,); +fn draw_len(tc: &TestCase) -> usize { + tc.draw(gs::integers::().max_value(MAX_LEN)) } -#[test] -fn mask_from() { - let masks = [ - Mask::from_indices(5, vec![0, 2, 3]), - Mask::from_slices(5, vec![(0, 1), (2, 4)]), - Mask::from_buffer(BitBuffer::from_iter([true, false, true, true, false])), - ]; - - for mask in &masks { - assert_eq!(mask.len(), 5); - assert_eq!(mask.true_count(), 3); - assert_eq!(mask.density(), 0.6); - assert_eq!(mask.indices(), AllOr::Some(&[0, 2, 3][..])); - assert_eq!(mask.slices(), AllOr::Some(&[(0, 1), (2, 4)][..])); - assert_eq!( - mask.bit_buffer(), - AllOr::Some(&BitBuffer::from_iter([true, false, true, true, false])) - ); +fn draw_bits(tc: &TestCase, len: usize) -> Vec { + match tc.draw(gs::integers::().max_value(2)) { + 0 => vec![true; len], + 1 => vec![false; len], + _ => tc.draw(gs::vecs(gs::booleans()).min_size(len).max_size(len)), } } -#[test] -fn length_zero_masks() { - let all_false = Mask::new_false(0); - let all_true = Mask::new_true(0); - let buffer_set = Mask::from_buffer(BitBuffer::new_set(0)); - let buffer_unset = Mask::from_buffer(BitBuffer::new_unset(0)); - - assert!(all_false.all_false()); - assert!(all_false.all_true()); - assert!(all_true.all_false()); - assert!(all_true.all_true()); - assert!(buffer_set.all_false()); - assert!(buffer_set.all_true()); - assert!(buffer_unset.all_false()); - assert!(buffer_unset.all_true()); -} - -// Mask value access tests -#[test] -fn test_mask_value() { - let all_true = Mask::new_true(5); - assert!(all_true.value(0)); - assert!(all_true.value(4)); - - let all_false = Mask::new_false(5); - assert!(!all_false.value(0)); - assert!(!all_false.value(4)); - - let values = Mask::from_buffer(BitBuffer::from_iter([true, false, true, false, true])); - assert!(values.value(0)); - assert!(!values.value(1)); - assert!(values.value(2)); - assert!(!values.value(3)); - assert!(values.value(4)); +fn build_mask(tc: &TestCase, bits: &[bool]) -> Mask { + let len = bits.len(); + match tc.draw(gs::integers::().max_value(4)) { + 0 if bits.iter().all(|&b| b) => Mask::new_true(len), + 0 if !bits.iter().any(|&b| b) => Mask::new_false(len), + 0 | 1 => Mask::from_iter(bits.iter().copied()), + 2 => Mask::from_indices(len, model_indices(bits)), + 3 => Mask::from_slices(len, model_slices(bits)), + _ => { + let offset = tc.draw(gs::integers::().max_value(63)); + let mut source = vec![true; offset]; + source.extend_from_slice(bits); + source.extend([false, true, false]); + Mask::from_buffer(BitBuffer::from(source).slice(offset..offset + len)) + } + } } -#[test] -fn test_mask_first() { - assert_eq!(Mask::new_true(5).first(), Some(0)); - assert_eq!(Mask::new_false(5).first(), None); - assert_eq!(Mask::new_true(0).first(), None); - - let values = Mask::from_buffer(BitBuffer::from_iter([false, false, true, false, true])); - assert_eq!(values.first(), Some(2)); - - let values_indices = Mask::from_indices(5, vec![2, 4]); - assert_eq!(values_indices.first(), Some(2)); - - let values_slices = Mask::from_slices(5, vec![(2, 3), (4, 5)]); - assert_eq!(values_slices.first(), Some(2)); +fn draw_mask_of_len(tc: &TestCase, len: usize) -> (Mask, Vec) { + let bits = draw_bits(tc, len); + (build_mask(tc, &bits), bits) } -#[test] -fn test_mask_last() { - assert_eq!(Mask::new_true(5).last(), Some(4)); - assert_eq!(Mask::new_false(5).last(), None); - assert_eq!(Mask::new_true(0).last(), None); - - let buffer = BitBuffer::from_iter([true, false, true, false, true, false, true]); - let values = Mask::from_buffer(buffer.slice(1..6)); - assert_eq!(values.last(), Some(3)); - - let values_indices = Mask::from_indices(5, vec![1, 3]); - assert_eq!(values_indices.last(), Some(3)); - - let values_slices = Mask::from_slices(5, vec![(1, 2), (3, 4)]); - assert_eq!(values_slices.last(), Some(3)); +fn draw_mask(tc: &TestCase) -> (Mask, Vec) { + let len = draw_len(tc); + draw_mask_of_len(tc, len) } -// Slice operations -#[test] -fn test_mask_slice() { - let mask = Mask::from_buffer(BitBuffer::from_iter([true, false, true, true, false])); - - let sliced = mask.slice(1..4); - assert_eq!(sliced.len(), 3); - assert_eq!(sliced.true_count(), 2); - assert!(!sliced.value(0)); // false from index 1 - assert!(sliced.value(1)); // true from index 2 - assert!(sliced.value(2)); // true from index 3 - - let all_true = Mask::new_true(10); - let sliced_true = all_true.slice(2..7); - assert!(sliced_true.all_true()); - assert_eq!(sliced_true.len(), 5); - - let all_false = Mask::new_false(10); - let sliced_false = all_false.slice(2..7); - assert!(sliced_false.all_false()); - assert_eq!(sliced_false.len(), 5); +fn model_indices(bits: &[bool]) -> Vec { + bits.iter() + .enumerate() + .filter_map(|(i, &b)| b.then_some(i)) + .collect() } -#[test] -#[should_panic] -fn test_mask_slice_out_of_bounds() { - let mask = Mask::new_true(5); - mask.slice(3..8); // offset + length > len +fn model_slices(bits: &[bool]) -> Vec<(usize, usize)> { + let mut slices: Vec<(usize, usize)> = Vec::new(); + for i in model_indices(bits) { + match slices.last_mut() { + Some((_, end)) if *end == i => *end += 1, + _ => slices.push((i, i + 1)), + } + } + slices +} + +fn assert_matches_model(mask: &Mask, bits: &[bool]) { + let indices = model_indices(bits); + let slices = model_slices(bits); + assert_counts_match(mask, bits.len(), &indices); + assert_elements_match(mask, bits, &indices); + assert_representations_match(mask, bits, &indices, &slices); + assert_values_match(mask, bits, &indices, &slices); +} + +fn assert_counts_match(mask: &Mask, len: usize, indices: &[usize]) { + assert_eq!(mask.len(), len); + assert_eq!(mask.is_empty(), len == 0); + assert_eq!(mask.true_count(), indices.len()); + assert_eq!(mask.false_count(), len - indices.len()); + assert_eq!(mask.all_true(), indices.len() == len); + assert_eq!(mask.all_false(), indices.is_empty()); + if len > 0 { + #[expect(clippy::cast_precision_loss)] + let density = indices.len() as f64 / len as f64; + assert!((mask.density() - density).abs() < 1e-10); + } } -// Limit operations -#[test] -fn limit_all_true_mask() { - let all_true = Mask::new_true(4); - let limited_mask = all_true.clone().limit(2); - assert_eq!(all_true.len(), limited_mask.len()); - assert_eq!(limited_mask.true_count(), 2); - assert_eq!( - limited_mask.bit_buffer(), - AllOr::Some(&BitBuffer::from_iter([true, true, false, false])) - ); - - let limited_mask = all_true.clone().limit(5); - assert_eq!(limited_mask, all_true); +fn assert_elements_match(mask: &Mask, bits: &[bool], indices: &[usize]) { + let len = bits.len(); + assert_eq!(mask.iter().collect::>(), bits); + assert_eq!(mask.iter().len(), len); + assert_eq!((0..len).map(|i| mask.value(i)).collect::>(), bits); + assert_eq!(mask.first(), indices.first().copied()); + assert_eq!(mask.last(), indices.last().copied()); + for (n, &idx) in indices.iter().enumerate() { + assert_eq!(mask.rank(n), idx); + } } -#[test] -fn limit_mask_values() { - let original_mask = Mask::from_iter([true, true, false, true, false, true]); - let limited_mask = original_mask.clone().limit(2); - - assert_eq!( - limited_mask.bit_buffer(), - AllOr::Some(&BitBuffer::from_iter([ - true, true, false, false, false, false - ])) +fn assert_representations_match( + mask: &Mask, + bits: &[bool], + indices: &[usize], + slices: &[(usize, usize)], +) { + let len = bits.len(); + let mask_indices = match mask.indices() { + AllOr::All => (0..len).collect(), + AllOr::None => Vec::new(), + AllOr::Some(indices) => indices.to_vec(), + }; + assert_eq!(mask_indices, indices); + + let mask_slices = match mask.slices() { + AllOr::All if len > 0 => vec![(0, len)], + AllOr::All | AllOr::None => Vec::new(), + AllOr::Some(slices) => slices.to_vec(), + }; + assert_eq!(mask_slices, slices); + + let buffer_bits = match mask.bit_buffer() { + AllOr::All => vec![true; len], + AllOr::None => vec![false; len], + AllOr::Some(buffer) => buffer.iter().collect(), + }; + assert_eq!(buffer_bits, bits); + assert_eq!(mask.to_bit_buffer().iter().collect::>(), bits); +} + +fn assert_values_match(mask: &Mask, bits: &[bool], indices: &[usize], slices: &[(usize, usize)]) { + let len = bits.len(); + let Some(values) = mask.values() else { + return; + }; + assert!(!values.is_empty()); + assert_eq!(values.len(), len); + assert_eq!(values.true_count(), indices.len()); + assert_eq!(values.indices(), indices); + assert_eq!(values.slices(), slices); + assert_eq!(values.bit_buffer().iter().collect::>(), bits); + assert_eq!((0..len).map(|i| values.value(i)).collect::>(), bits); +} + +#[hegel::test] +fn mask(tc: TestCase) { + let (mask, bits) = draw_mask(&tc); + assert_matches_model(&mask, &bits); +} + +#[hegel::test] +fn mask_eq(tc: TestCase) { + let (lhs, lhs_bits) = draw_mask(&tc); + let rhs_bits = if tc.draw(gs::booleans()) { + lhs_bits.clone() + } else { + let len = if tc.draw(gs::booleans()) { + lhs_bits.len() + } else { + draw_len(&tc) + }; + draw_bits(&tc, len) + }; + let rhs = build_mask(&tc, &rhs_bits); + + assert_eq!(lhs == rhs, lhs_bits == rhs_bits); + assert_eq!(rhs == lhs, lhs_bits == rhs_bits); +} + +#[hegel::test] +fn mask_slice(tc: TestCase) { + let (mask, bits) = draw_mask(&tc); + let end = tc.draw(gs::integers::().max_value(bits.len())); + let start = tc.draw(gs::integers::().max_value(end)); + assert_matches_model(&mask.slice(start..end), &bits[start..end]); +} + +#[hegel::test] +fn mask_limit(tc: TestCase) { + let (mask, bits) = draw_mask(&tc); + let limit = tc.draw(gs::integers::().max_value(bits.len() + 2)); + let mut remaining = limit; + let expected: Vec = bits + .iter() + .map(|&b| { + let keep = b && remaining > 0; + if keep { + remaining -= 1; + } + keep + }) + .collect(); + assert_matches_model(&mask.limit(limit), &expected); +} + +#[hegel::test] +fn mask_bitops(tc: TestCase) { + let len = draw_len(&tc); + let (lhs, lhs_bits) = draw_mask_of_len(&tc, len); + let (rhs, rhs_bits) = draw_mask_of_len(&tc, len); + let zip = |f: fn(bool, bool) -> bool| -> Vec { + lhs_bits + .iter() + .zip(&rhs_bits) + .map(|(&l, &r)| f(l, r)) + .collect() + }; + + let and = zip(|l, r| l & r); + let or = zip(|l, r| l | r); + let and_not = zip(|l, r| l & !r); + let not: Vec = lhs_bits.iter().map(|&b| !b).collect(); + + assert_matches_model(&(&lhs & &rhs), &and); + assert_matches_model(&(lhs.clone() & &rhs), &and); + assert_matches_model(&(&lhs | &rhs), &or); + assert_matches_model(&(lhs.clone() | &rhs), &or); + assert_matches_model(&lhs.clone().bitand_not(&rhs), &and_not); + assert_matches_model(&!&lhs, ¬); + assert_matches_model(&!lhs, ¬); +} + +#[hegel::test] +fn mask_concat(tc: TestCase) { + let count = tc.draw(gs::integers::().max_value(4)); + let (masks, bits): (Vec, Vec>) = (0..count) + .map(|_| { + let len = tc.draw(gs::integers::().max_value(MAX_LEN / 4)); + draw_mask_of_len(&tc, len) + }) + .unzip(); + let expected = bits.concat(); + + assert_matches_model(&Mask::concat(masks.iter()).unwrap(), &expected); + assert_matches_model(&Mask::from_iter(masks), &expected); +} + +#[hegel::test] +fn mask_from_excluded(tc: TestCase) { + let len = draw_len(&tc); + let bits = draw_bits(&tc, len); + let excluded: Vec = bits.iter().map(|&b| !b).collect(); + assert_matches_model( + &Mask::from_excluded_indices(len, model_indices(&excluded)), + &bits, ); - assert_eq!(limited_mask.true_count(), 2); - - let limited_mask = original_mask.limit(3); +} - assert_eq!( - limited_mask.bit_buffer(), - AllOr::Some(&BitBuffer::from_iter([ - true, true, false, true, false, false - ])) +#[hegel::test] +fn mask_from_intersection(tc: TestCase) { + let len = draw_len(&tc); + let lhs = draw_bits(&tc, len); + let rhs = draw_bits(&tc, len); + let expected: Vec = lhs.iter().zip(&rhs).map(|(&l, &r)| l && r).collect(); + let mask = Mask::from_intersection_indices( + len, + model_indices(&lhs).into_iter(), + model_indices(&rhs).into_iter(), ); - assert_eq!(limited_mask.true_count(), 3); - - let original_mask = Mask::from_iter([true, true, false, true, false, true]); - let limited_mask = original_mask.clone().limit(100); - - assert_eq!(original_mask, limited_mask); + assert_matches_model(&mask, &expected); +} + +#[hegel::test] +fn mask_valid_counts(tc: TestCase) { + let (mask, bits) = draw_mask(&tc); + let mut indices: Vec = + tc.draw(gs::vecs(gs::integers::().max_value(bits.len())).max_size(MAX_LEN)); + indices.sort_unstable(); + let expected: Vec = indices + .iter() + .map(|&idx| bits[..idx].iter().filter(|&&b| b).count()) + .collect(); + assert_eq!(mask.valid_counts_for_indices(&indices), expected); +} + +#[hegel::test] +fn mask_intersect_by_rank(tc: TestCase) { + let (mask, bits) = draw_mask(&tc); + let (rank, rank_bits) = draw_mask_of_len(&tc, mask.true_count()); + let mut ranks = rank_bits.iter(); + let expected: Vec = bits + .iter() + .map(|&b| b && *ranks.next().unwrap_or(&false)) + .collect(); + assert_matches_model(&mask.intersect_by_rank(&rank), &expected); } -#[test] -fn test_limit_all_false_mask() { - let all_false = Mask::new_false(10); - let limited = all_false.clone().limit(5); - assert_eq!(limited, all_false); - assert!(limited.all_false()); -} +#[rstest] +#[case::all_true(Mask::new_true(4), vec![true, true, true, true])] +#[case::all_false(Mask::new_false(3), vec![false, false, false])] +#[case::values( + Mask::from_buffer(BitBuffer::from_iter([true, false, true, true, false])), + vec![true, false, true, true, false] +)] +#[case::empty(Mask::new_true(0), vec![])] +fn mask_iter_matches_value(#[case] mask: Mask, #[case] expected: Vec) { + let collected: Vec = mask.iter().collect(); + assert_eq!(collected, expected); -#[test] -fn test_limit_mask_exact() { - let mask = Mask::from_buffer(BitBuffer::from_iter([true, false, true, false, true])); - let limited = mask.clone().limit(3); - assert_eq!(limited.true_count(), 3); - assert_eq!(limited, mask); -} + let by_value: Vec = (0..mask.len()).map(|i| mask.value(i)).collect(); + assert_eq!(collected, by_value); -#[test] -fn test_limit_mask_zero() { - let mask = Mask::from_buffer(BitBuffer::from_iter([true, false, true, false, true])); - let limited = mask.limit(0); - assert!(limited.all_false()); - assert_eq!(limited.true_count(), 0); + let mut it = mask.iter(); + assert_eq!(it.len(), mask.len()); + if it.next().is_some() { + assert_eq!(it.len(), mask.len() - 1); + } } -// Buffer conversion tests #[test] -fn test_mask_to_bit_buffer() { - let all_true = Mask::new_true(5); - let buffer = all_true.to_bit_buffer(); - assert_eq!(buffer.true_count(), 5); - assert_eq!(buffer.len(), 5); - - let all_false = Mask::new_false(5); - let buffer = all_false.to_bit_buffer(); - assert_eq!(buffer.true_count(), 0); - assert_eq!(buffer.len(), 5); - - let values = Mask::from_buffer(BitBuffer::from_iter([true, false, true, false, true])); - let buffer = values.to_bit_buffer(); - assert_eq!(buffer.true_count(), 3); - assert_eq!(buffer.len(), 5); +#[should_panic] +fn test_mask_slice_out_of_bounds() { + let mask = Mask::new_true(5); + mask.slice(3..8); // offset + length > len } -// MaskValues tests #[test] -fn test_mask_values() { - let all_true = Mask::new_true(5); - assert!(all_true.values().is_none()); - - let all_false = Mask::new_false(5); - assert!(all_false.values().is_none()); - - let mask = Mask::from_buffer(BitBuffer::from_iter([true, false, true, false, true])); - let values = mask.values().unwrap(); - assert_eq!(values.len(), 5); - assert_eq!(values.true_count(), 3); - assert!(values.value(0)); - assert!(!values.value(1)); +#[should_panic(expected = "Masks must have the same length")] +fn test_bitand_different_lengths() { + let mask1 = Mask::new_true(5); + let mask2 = Mask::new_true(3); + let _unused = &mask1 & &mask2; } #[test] @@ -330,100 +403,6 @@ fn mask_from_buffer_with_slices_unset_bit() { ); } -#[test] -fn test_mask_values_is_empty() { - let empty_mask = Mask::from_buffer(BitBuffer::new_unset(0)); - assert!(empty_mask.values().is_none()); - - let non_empty_mask = Mask::from_buffer(BitBuffer::from_iter([true, false])); - assert!(!non_empty_mask.values().unwrap().is_empty()); -} - -// Creation from excluded indices -#[test] -fn test_mask_from_excluded_indices() { - let mask = Mask::from_excluded_indices(5, vec![1, 3]); - assert_eq!(mask.len(), 5); - assert_eq!(mask.true_count(), 3); - assert!(mask.value(0)); - assert!(!mask.value(1)); - assert!(mask.value(2)); - assert!(!mask.value(3)); - assert!(mask.value(4)); - - let mask_empty = Mask::from_excluded_indices(5, vec![]); - assert!(mask_empty.all_true()); - // Verify it returns the optimized AllTrue variant - assert!(matches!(mask_empty, Mask::AllTrue(5))); - - let mask_all = Mask::from_excluded_indices(3, vec![0, 1, 2]); - assert!(mask_all.all_false()); - // Verify it returns the optimized AllFalse variant - assert!(matches!(mask_all, Mask::AllFalse(3))); -} - -// Intersection tests -#[test] -fn test_mask_from_intersection_indices() { - let lhs = vec![0, 2, 3, 5, 7, 9]; - let rhs = vec![1, 2, 3, 4, 7, 8, 9]; - - let mask = Mask::from_intersection_indices(10, lhs.into_iter(), rhs.into_iter()); - assert_eq!(mask.len(), 10); - assert_eq!(mask.true_count(), 4); // 2, 3, 7, 9 - assert!(!mask.value(0)); - assert!(!mask.value(1)); - assert!(mask.value(2)); - assert!(mask.value(3)); - assert!(!mask.value(4)); - assert!(!mask.value(5)); - assert!(!mask.value(6)); - assert!(mask.value(7)); - assert!(!mask.value(8)); - assert!(mask.value(9)); -} - -#[test] -fn test_mask_from_intersection_indices_empty() { - let lhs = vec![0, 2, 4]; - let rhs = vec![1, 3, 5]; - - let mask = Mask::from_intersection_indices(6, lhs.into_iter(), rhs.into_iter()); - assert!(mask.all_false()); - assert_eq!(mask.true_count(), 0); -} - -#[test] -fn test_mask_from_intersection_indices_same() { - let indices = vec![1, 3, 5, 7]; - - let mask = - Mask::from_intersection_indices(10, indices.clone().into_iter(), indices.into_iter()); - assert_eq!(mask.len(), 10); - assert_eq!(mask.true_count(), 4); - assert!(mask.value(1)); - assert!(mask.value(3)); - assert!(mask.value(5)); - assert!(mask.value(7)); -} - -// Valid counts tests -#[test] -fn test_mask_valid_counts_for_indices() { - let mask = Mask::from_buffer(BitBuffer::from_iter([true, false, true, true, false, true])); - let indices = vec![0, 2, 4, 6]; - let counts = mask.valid_counts_for_indices(&indices); - assert_eq!(counts, vec![0, 1, 3, 4]); - - let all_true = Mask::new_true(6); - let counts = all_true.valid_counts_for_indices(&indices); - assert_eq!(counts, vec![0, 2, 4, 6]); - - let all_false = Mask::new_false(6); - let counts = all_false.valid_counts_for_indices(&indices); - assert_eq!(counts, vec![0, 0, 0, 0]); -} - #[test] #[should_panic] fn test_mask_valid_counts_for_indices_error() { @@ -432,67 +411,6 @@ fn test_mask_valid_counts_for_indices_error() { mask.valid_counts_for_indices(&indices); } -// FromIterator tests -#[test] -fn test_mask_from_iter_masks() { - let masks = vec![ - Mask::from_buffer(BitBuffer::from_iter([true, false])), - Mask::from_buffer(BitBuffer::from_iter([true, true, false])), - Mask::from_buffer(BitBuffer::from_iter([false, true])), - ]; - - let combined = Mask::from_iter(masks); - assert_eq!(combined.len(), 7); - assert_eq!(combined.true_count(), 4); - assert!(combined.value(0)); - assert!(!combined.value(1)); - assert!(combined.value(2)); - assert!(combined.value(3)); - assert!(!combined.value(4)); - assert!(!combined.value(5)); - assert!(combined.value(6)); -} - -#[test] -fn test_mask_from_iter_all_true() { - let masks = vec![Mask::new_true(3), Mask::new_true(2), Mask::new_true(4)]; - - let combined = Mask::from_iter(masks); - assert!(combined.all_true()); - assert_eq!(combined.len(), 9); -} - -#[test] -fn test_mask_from_iter_all_false() { - let masks = vec![Mask::new_false(3), Mask::new_false(2), Mask::new_false(4)]; - - let combined = Mask::from_iter(masks); - assert!(combined.all_false()); - assert_eq!(combined.len(), 9); -} - -#[test] -fn test_mask_from_iter_empty() { - let masks: Vec = vec![]; - let combined = Mask::from_iter(masks); - assert_eq!(combined.len(), 0); - assert!(combined.is_empty()); -} - -#[test] -fn test_mask_from_iter_with_empty_masks() { - let masks = vec![ - Mask::new_true(3), - Mask::new_true(0), // empty mask - Mask::new_false(2), - ]; - - let combined = Mask::from_iter(masks); - assert_eq!(combined.len(), 5); - assert_eq!(combined.true_count(), 3); -} - -// Panic tests for invalid inputs #[test] #[should_panic] fn test_mask_from_indices_unsorted() { @@ -535,7 +453,6 @@ fn test_mask_from_slices_overlapping() { Mask::from_slices(5, vec![(0, 3), (2, 4)]); // Overlapping ranges } -// Threshold iterator tests #[test] fn test_mask_threshold_iter() { let all_true = Mask::new_true(5); @@ -552,7 +469,6 @@ fn test_mask_threshold_iter() { } } -// Caching tests #[test] fn test_mask_indices_caching() { // Test that indices are properly cached @@ -595,7 +511,6 @@ fn test_mask_slices_caching() { } } -// AllOr tests #[test] fn test_allor_unwrap_or_else() { let all: AllOr = AllOr::All; @@ -645,165 +560,3 @@ fn test_allor_eq() { assert_ne!(all1, some1); assert_ne!(none1, some1); } - -// Parameterized tests with rstest -#[rstest] -#[case::all_true(Mask::new_true(5), 5, 5, 0, 1.0)] -#[case::all_false(Mask::new_false(5), 5, 0, 5, 0.0)] -#[case::mixed( - Mask::from_buffer(BitBuffer::from_iter([true, false, true, false, true])), - 5, 3, 2, 0.6 - )] -#[case::single_true(Mask::from_indices(10, vec![5]), 10, 1, 9, 0.1)] -#[case::dense(Mask::from_indices(10, vec![0, 1, 2, 3, 4, 5, 6, 7, 8]), 10, 9, 1, 0.9)] -fn test_mask_properties( - #[case] mask: Mask, - #[case] expected_len: usize, - #[case] expected_true: usize, - #[case] expected_false: usize, - #[case] expected_density: f64, -) { - assert_eq!(mask.len(), expected_len); - assert_eq!(mask.true_count(), expected_true); - assert_eq!(mask.false_count(), expected_false); - assert!((mask.density() - expected_density).abs() < 1e-10); -} - -#[rstest] -#[case::indices(vec![0, 2, 4], vec![(0, 1), (2, 3), (4, 5)])] -#[case::consecutive(vec![0, 1, 2], vec![(0, 3)])] -#[case::gap(vec![0, 1, 4, 5], vec![(0, 2), (4, 6)])] -#[case::single(vec![3], vec![(3, 4)])] -fn test_indices_to_slices_conversion( - #[case] indices: Vec, - #[case] expected_slices: Vec<(usize, usize)>, -) { - let mask = Mask::from_indices(10, indices.clone()); - - // Check indices - if let AllOr::Some(actual_indices) = mask.indices() { - assert_eq!(actual_indices, &indices[..]); - } else { - panic!("Expected Some variant for indices"); - } - - // Check slices - if let AllOr::Some(actual_slices) = mask.slices() { - assert_eq!(actual_slices, &expected_slices[..]); - } else { - panic!("Expected Some variant for slices"); - } -} - -#[rstest] -#[case::empty_intersection(vec![0, 2, 4], vec![1, 3, 5], vec![])] -#[case::full_intersection(vec![1, 3, 5], vec![1, 3, 5], vec![1, 3, 5])] -#[case::partial_intersection(vec![0, 1, 2, 3], vec![2, 3, 4, 5], vec![2, 3])] -#[case::subset_left(vec![1, 2], vec![0, 1, 2, 3], vec![1, 2])] -#[case::subset_right(vec![0, 1, 2, 3], vec![1, 2], vec![1, 2])] -fn test_intersection_indices( - #[case] left: Vec, - #[case] right: Vec, - #[case] expected: Vec, -) { - let mask = Mask::from_intersection_indices(10, left.into_iter(), right.into_iter()); - - match mask.indices() { - AllOr::Some(indices) if expected.is_empty() => assert!(indices.is_empty()), - AllOr::Some(indices) => assert_eq!(indices, &expected[..]), - AllOr::None if expected.is_empty() => {} - AllOr::None | AllOr::All => panic!("Unexpected result for intersection"), - } -} - -// Concat operation tests -#[test] -fn test_mask_concat_empty() { - let masks: Vec = vec![]; - let result = Mask::concat(masks.iter()).unwrap(); - assert_eq!(result.len(), 0); - assert!(result.is_empty()); -} - -#[test] -fn test_mask_concat_all_true() { - let masks = [Mask::new_true(3), Mask::new_true(2)]; - let result = Mask::concat(masks.iter()).unwrap(); - assert_eq!(result.len(), 5); - assert!(result.all_true()); -} - -#[test] -fn test_mask_concat_all_false() { - let masks = [Mask::new_false(3), Mask::new_false(2)]; - let result = Mask::concat(masks.iter()).unwrap(); - assert_eq!(result.len(), 5); - assert!(result.all_false()); -} - -#[test] -fn test_mask_concat_mixed_types() { - let masks = [ - Mask::from_buffer(BitBuffer::from_iter([true, false, true])), - Mask::new_true(2), - Mask::new_false(3), - ]; - - let result = Mask::concat(masks.iter()).unwrap(); - assert_eq!(result.len(), 8); - assert_eq!(result.true_count(), 4); - - // Verify the concatenated values - assert!(result.value(0)); // from buffer - assert!(!result.value(1)); // from buffer - assert!(result.value(2)); // from buffer - assert!(result.value(3)); // from all_true - assert!(result.value(4)); // from all_true - assert!(!result.value(5)); // from all_false - assert!(!result.value(6)); // from all_false - assert!(!result.value(7)); // from all_false -} - -// `Mask::iter` per-element bool iteration - -#[rstest] -#[case::all_true(Mask::new_true(4), vec![true, true, true, true])] -#[case::all_false(Mask::new_false(3), vec![false, false, false])] -#[case::values( - Mask::from_buffer(BitBuffer::from_iter([true, false, true, true, false])), - vec![true, false, true, true, false] -)] -#[case::empty(Mask::new_true(0), vec![])] -fn mask_iter_matches_value(#[case] mask: Mask, #[case] expected: Vec) { - // Iterator yields exactly one bool per element, matching `value`. - let collected: Vec = mask.iter().collect(); - assert_eq!(collected, expected); - - let by_value: Vec = (0..mask.len()).map(|i| mask.value(i)).collect(); - assert_eq!(collected, by_value); - - // ExactSizeIterator reports the right length, including after partial consumption. - let mut it = mask.iter(); - assert_eq!(it.len(), mask.len()); - if it.next().is_some() { - assert_eq!(it.len(), mask.len() - 1); - } -} - -/// `from_excluded_indices` must count each excluded position once: `[0, 0]` excludes a single row. -#[rstest] -#[case::fewer_than_len(vec![0, 0], vec![1, 2])] -#[case::equal_to_len(vec![0, 0, 0], vec![1, 2])] -#[case::more_than_len(vec![0, 0, 0, 0], vec![1, 2])] -#[case::non_adjacent(vec![2, 0, 2], vec![1])] -#[case::all_excluded(vec![2, 0, 2, 1], vec![])] -fn from_excluded_indices_counts_duplicates_once( - #[case] excluded: Vec, - #[case] included: Vec, -) { - let mask = Mask::from_excluded_indices(3, excluded); - assert_eq!(mask.true_count(), included.len()); - let expected = Mask::from_indices(3, included); - assert_eq!(mask, expected); - assert_eq!(mask.density(), expected.density()); -} From 71b16db9ed67597437ab72d2d75146c1b7bc4670 Mon Sep 17 00:00:00 2001 From: Mikhail Kot Date: Tue, 3 Nov 2026 18:02:02 +0000 Subject: [PATCH 2/2] check duplicated excluded indices as well Signed-off-by: Mikhail Kot --- vortex-mask/src/tests.rs | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/vortex-mask/src/tests.rs b/vortex-mask/src/tests.rs index 94e49c665ba..0b4bdeb1316 100644 --- a/vortex-mask/src/tests.rs +++ b/vortex-mask/src/tests.rs @@ -246,11 +246,15 @@ fn mask_concat(tc: TestCase) { fn mask_from_excluded(tc: TestCase) { let len = draw_len(&tc); let bits = draw_bits(&tc, len); - let excluded: Vec = bits.iter().map(|&b| !b).collect(); - assert_matches_model( - &Mask::from_excluded_indices(len, model_indices(&excluded)), - &bits, - ); + let mut excluded = Vec::new(); + for (i, _) in bits.iter().enumerate().filter(|&(_, &b)| !b) { + let copies = tc.draw(gs::integers::().min_value(1).max_value(3)); + for _ in 0..copies { + let pos = tc.draw(gs::integers::().max_value(excluded.len())); + excluded.insert(pos, i); + } + } + assert_matches_model(&Mask::from_excluded_indices(len, excluded), &bits); } #[hegel::test]