| use fixedbitset::*; |
| |
| #[cfg(target_family = "wasm")] |
| use wasm_bindgen_test::*; |
| #[cfg(target_family = "wasm")] |
| wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser); |
| |
| extern crate alloc; |
| |
| const BITS: usize = core::mem::size_of::<Block>() * 8; |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn it_works() { |
| const N: usize = 50; |
| let mut fb = FixedBitSet::with_capacity(N); |
| |
| for i in 0..(N + 10) { |
| assert_eq!(fb.contains(i), false); |
| } |
| |
| fb.insert(10); |
| fb.set(11, false); |
| fb.set(12, false); |
| fb.set(12, true); |
| fb.set(N - 1, true); |
| |
| assert!(fb.contains(10)); |
| assert!(!fb.contains(11)); |
| assert!(fb.contains(12)); |
| assert!(fb.contains(N - 1)); |
| for i in 0..N { |
| let contain = i == 10 || i == 12 || i == N - 1; |
| assert_eq!(contain, fb[i]); |
| } |
| |
| fb.clear(); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn with_blocks() { |
| let fb = FixedBitSet::with_capacity_and_blocks(50, vec![8, 0]); |
| assert!(fb.contains(3)); |
| |
| let ones: Vec<_> = fb.ones().collect(); |
| assert_eq!(ones.len(), 1); |
| |
| let ones: Vec<_> = fb.ones().rev().collect(); |
| assert_eq!(ones.len(), 1); |
| |
| let ones: Vec<_> = fb.ones().rev().alternate().collect(); |
| assert_eq!(ones.len(), 1); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn with_blocks_too_small() { |
| let mut fb = FixedBitSet::with_capacity_and_blocks(500, vec![8, 0]); |
| fb.insert(400); |
| assert!(fb.contains(400)); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn with_blocks_too_big() { |
| let fb = FixedBitSet::with_capacity_and_blocks(1, vec![8]); |
| |
| // since capacity is 1, 3 shouldn't be set here |
| assert!(!fb.contains(3)); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn with_blocks_too_big_range_check() { |
| let fb = FixedBitSet::with_capacity_and_blocks(1, vec![0xff]); |
| |
| // since capacity is 1, only 0 should be set |
| assert!(fb.contains(0)); |
| for i in 1..0xff { |
| assert!(!fb.contains(i)); |
| } |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn grow() { |
| let mut fb = FixedBitSet::with_capacity(48); |
| for i in 0..fb.len() { |
| fb.set(i, true); |
| } |
| |
| let old_len = fb.len(); |
| fb.grow(72); |
| for j in 0..fb.len() { |
| assert_eq!(fb.contains(j), j < old_len); |
| } |
| fb.set(64, true); |
| assert!(fb.contains(64)); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn grow_and_insert() { |
| let mut fb = FixedBitSet::default(); |
| for i in 0..100 { |
| if i % 3 == 0 { |
| fb.grow_and_insert(i); |
| } |
| } |
| |
| assert_eq!(fb.count_ones(..), 34); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn test_toggle() { |
| let mut fb = FixedBitSet::with_capacity(16); |
| fb.toggle(1); |
| fb.put(2); |
| fb.toggle(2); |
| fb.put(3); |
| assert!(fb.contains(1)); |
| assert!(!fb.contains(2)); |
| assert!(fb.contains(3)); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn copy_bit() { |
| let mut fb = FixedBitSet::with_capacity(48); |
| for i in 0..fb.len() { |
| fb.set(i, true); |
| } |
| fb.set(42, false); |
| fb.copy_bit(42, 2); |
| assert!(!fb.contains(42)); |
| assert!(!fb.contains(2)); |
| assert!(fb.contains(1)); |
| fb.copy_bit(1, 42); |
| assert!(fb.contains(42)); |
| fb.copy_bit(1024, 42); |
| assert!(!fb[42]); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn count_ones() { |
| let mut fb = FixedBitSet::with_capacity(100); |
| fb.set(11, true); |
| fb.set(12, true); |
| fb.set(7, true); |
| fb.set(35, true); |
| fb.set(40, true); |
| fb.set(77, true); |
| fb.set(95, true); |
| fb.set(50, true); |
| fb.set(99, true); |
| assert_eq!(fb.count_ones(..7), 0); |
| assert_eq!(fb.count_ones(..8), 1); |
| assert_eq!(fb.count_ones(..11), 1); |
| assert_eq!(fb.count_ones(..12), 2); |
| assert_eq!(fb.count_ones(..13), 3); |
| assert_eq!(fb.count_ones(..35), 3); |
| assert_eq!(fb.count_ones(..36), 4); |
| assert_eq!(fb.count_ones(..40), 4); |
| assert_eq!(fb.count_ones(..41), 5); |
| assert_eq!(fb.count_ones(50..), 4); |
| assert_eq!(fb.count_ones(70..95), 1); |
| assert_eq!(fb.count_ones(70..96), 2); |
| assert_eq!(fb.count_ones(70..99), 2); |
| assert_eq!(fb.count_ones(..), 9); |
| assert_eq!(fb.count_ones(0..100), 9); |
| assert_eq!(fb.count_ones(0..0), 0); |
| assert_eq!(fb.count_ones(100..100), 0); |
| assert_eq!(fb.count_ones(7..), 9); |
| assert_eq!(fb.count_ones(8..), 8); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn count_zeroes() { |
| let mut fb = FixedBitSet::with_capacity(100); |
| fb.set(11, true); |
| fb.set(12, true); |
| fb.set(7, true); |
| fb.set(35, true); |
| fb.set(40, true); |
| fb.set(77, true); |
| fb.set(95, true); |
| fb.set(50, true); |
| fb.set(99, true); |
| assert_eq!(fb.count_zeroes(..7), 7); |
| assert_eq!(fb.count_zeroes(..8), 7); |
| assert_eq!(fb.count_zeroes(..11), 10); |
| assert_eq!(fb.count_zeroes(..12), 10); |
| assert_eq!(fb.count_zeroes(..13), 10); |
| assert_eq!(fb.count_zeroes(..35), 32); |
| assert_eq!(fb.count_zeroes(..36), 32); |
| assert_eq!(fb.count_zeroes(..40), 36); |
| assert_eq!(fb.count_zeroes(..41), 36); |
| assert_eq!(fb.count_zeroes(50..), 46); |
| assert_eq!(fb.count_zeroes(70..95), 24); |
| assert_eq!(fb.count_zeroes(70..96), 24); |
| assert_eq!(fb.count_zeroes(70..99), 27); |
| assert_eq!(fb.count_zeroes(..), 91); |
| assert_eq!(fb.count_zeroes(0..100), 91); |
| assert_eq!(fb.count_zeroes(0..0), 0); |
| assert_eq!(fb.count_zeroes(100..100), 0); |
| assert_eq!(fb.count_zeroes(7..), 84); |
| assert_eq!(fb.count_zeroes(8..), 84); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn minimum() { |
| let mut fb = FixedBitSet::with_capacity(100); |
| assert_eq!(fb.minimum(), None); |
| fb.set(95, true); |
| assert_eq!(fb.minimum(), Some(95)); |
| fb.set(77, true); |
| assert_eq!(fb.minimum(), Some(77)); |
| fb.set(12, true); |
| assert_eq!(fb.minimum(), Some(12)); |
| fb.set(40, true); |
| assert_eq!(fb.minimum(), Some(12)); |
| fb.set(35, true); |
| assert_eq!(fb.minimum(), Some(12)); |
| fb.set(11, true); |
| assert_eq!(fb.minimum(), Some(11)); |
| fb.set(7, true); |
| assert_eq!(fb.minimum(), Some(7)); |
| fb.set(50, true); |
| assert_eq!(fb.minimum(), Some(7)); |
| fb.set(99, true); |
| assert_eq!(fb.minimum(), Some(7)); |
| fb.clear(); |
| assert_eq!(fb.minimum(), None); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn maximum() { |
| let mut fb = FixedBitSet::with_capacity(100); |
| assert_eq!(fb.maximum(), None); |
| fb.set(11, true); |
| assert_eq!(fb.maximum(), Some(11)); |
| fb.set(12, true); |
| assert_eq!(fb.maximum(), Some(12)); |
| fb.set(7, true); |
| assert_eq!(fb.maximum(), Some(12)); |
| fb.set(40, true); |
| assert_eq!(fb.maximum(), Some(40)); |
| fb.set(35, true); |
| assert_eq!(fb.maximum(), Some(40)); |
| fb.set(95, true); |
| assert_eq!(fb.maximum(), Some(95)); |
| fb.set(50, true); |
| assert_eq!(fb.maximum(), Some(95)); |
| fb.set(77, true); |
| assert_eq!(fb.maximum(), Some(95)); |
| fb.set(99, true); |
| assert_eq!(fb.maximum(), Some(99)); |
| fb.clear(); |
| assert_eq!(fb.maximum(), None); |
| } |
| |
| /* Helper for testing double ended iterator */ |
| #[cfg(test)] |
| struct Alternating<I> { |
| iter: I, |
| front: bool, |
| } |
| |
| #[cfg(test)] |
| impl<I: Iterator + DoubleEndedIterator> Iterator for Alternating<I> { |
| type Item = I::Item; |
| |
| fn size_hint(&self) -> (usize, Option<usize>) { |
| self.iter.size_hint() |
| } |
| fn next(&mut self) -> Option<Self::Item> { |
| if self.front { |
| self.front = false; |
| self.iter.next() |
| } else { |
| self.front = true; |
| self.iter.next_back() |
| } |
| } |
| } |
| #[cfg(test)] |
| trait AlternatingExt: Iterator + DoubleEndedIterator + Sized { |
| fn alternate(self) -> Alternating<Self> { |
| Alternating { |
| iter: self, |
| front: true, |
| } |
| } |
| } |
| |
| #[cfg(test)] |
| impl<I: Iterator + DoubleEndedIterator> AlternatingExt for I {} |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn ones() { |
| let mut fb = FixedBitSet::with_capacity(100); |
| fb.set(11, true); |
| fb.set(12, true); |
| fb.set(7, true); |
| fb.set(35, true); |
| fb.set(40, true); |
| fb.set(77, true); |
| fb.set(95, true); |
| fb.set(50, true); |
| fb.set(99, true); |
| |
| let ones: Vec<_> = fb.ones().collect(); |
| let ones_rev: Vec<_> = fb.ones().rev().collect(); |
| let ones_alternating: Vec<_> = fb.ones().alternate().collect(); |
| |
| let mut known_result = vec![7, 11, 12, 35, 40, 50, 77, 95, 99]; |
| |
| assert_eq!(known_result, ones); |
| known_result.reverse(); |
| assert_eq!(known_result, ones_rev); |
| let known_result: Vec<_> = known_result.into_iter().rev().alternate().collect(); |
| assert_eq!(known_result, ones_alternating); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn into_ones() { |
| fn create() -> FixedBitSet { |
| let mut fb = FixedBitSet::with_capacity(100); |
| fb.set(11, true); |
| fb.set(12, true); |
| fb.set(7, true); |
| fb.set(35, true); |
| fb.set(40, true); |
| fb.set(77, true); |
| fb.set(95, true); |
| fb.set(50, true); |
| fb.set(99, true); |
| fb |
| } |
| |
| let ones: Vec<_> = create().into_ones().collect(); |
| let ones_rev: Vec<_> = create().into_ones().rev().collect(); |
| let ones_alternating: Vec<_> = create().into_ones().alternate().collect(); |
| |
| let mut known_result = vec![7, 11, 12, 35, 40, 50, 77, 95, 99]; |
| |
| assert_eq!(known_result, ones); |
| known_result.reverse(); |
| assert_eq!(known_result, ones_rev); |
| let known_result: Vec<_> = known_result.into_iter().rev().alternate().collect(); |
| assert_eq!(known_result, ones_alternating); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn size_hint() { |
| let iters = if cfg!(miri) { 250 } else { 1000 }; |
| for s in 0..iters { |
| let mut bitset = FixedBitSet::with_capacity(s); |
| bitset.insert_range(..); |
| let mut t = s; |
| let mut iter = bitset.ones().rev(); |
| loop { |
| match iter.next() { |
| None => break, |
| Some(_) => { |
| t -= 1; |
| assert!(iter.size_hint().1.unwrap() >= t); |
| // factor two, because we have first block and last block |
| assert!(iter.size_hint().1.unwrap() <= t + 2 * BITS); |
| } |
| } |
| } |
| assert_eq!(t, 0); |
| } |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn size_hint_alternate() { |
| let iters = if cfg!(miri) { 250 } else { 1000 }; |
| for s in 0..iters { |
| let mut bitset = FixedBitSet::with_capacity(s); |
| bitset.insert_range(..); |
| let mut t = s; |
| extern crate std; |
| let mut iter = bitset.ones().alternate(); |
| loop { |
| match iter.next() { |
| None => break, |
| Some(_) => { |
| t -= 1; |
| assert!(iter.size_hint().1.unwrap() >= t); |
| assert!(iter.size_hint().1.unwrap() <= t + 3 * BITS); |
| } |
| } |
| } |
| assert_eq!(t, 0); |
| } |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn iter_ones_range() { |
| fn test_range(from: usize, to: usize, capa: usize) { |
| assert!(to <= capa); |
| let mut fb = FixedBitSet::with_capacity(capa); |
| for i in from..to { |
| fb.insert(i); |
| } |
| let ones: Vec<_> = fb.ones().collect(); |
| let expected: Vec<_> = (from..to).collect(); |
| let ones_rev: Vec<_> = fb.ones().rev().collect(); |
| let expected_rev: Vec<_> = (from..to).rev().collect(); |
| let ones_rev_alt: Vec<_> = fb.ones().rev().alternate().collect(); |
| let expected_rev_alt: Vec<_> = (from..to).rev().alternate().collect(); |
| assert_eq!(expected, ones); |
| assert_eq!(expected_rev, ones_rev); |
| assert_eq!(expected_rev_alt, ones_rev_alt); |
| } |
| |
| for i in 0..100 { |
| test_range(i, 100, 100); |
| test_range(0, i, 100); |
| } |
| } |
| |
| #[should_panic] |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn count_ones_oob() { |
| let fb = FixedBitSet::with_capacity(100); |
| fb.count_ones(90..101); |
| } |
| |
| #[should_panic] |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn count_ones_negative_range() { |
| let fb = FixedBitSet::with_capacity(100); |
| fb.count_ones(90..80); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn count_ones_panic() { |
| let iters = if cfg!(miri) { 48 } else { 128 }; |
| for i in 1..iters { |
| let fb = FixedBitSet::with_capacity(i); |
| for j in 0..fb.len() + 1 { |
| for k in j..fb.len() + 1 { |
| assert_eq!(fb.count_ones(j..k), 0); |
| } |
| } |
| } |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn default() { |
| let fb = FixedBitSet::default(); |
| assert_eq!(fb.len(), 0); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn insert_range() { |
| let mut fb = FixedBitSet::with_capacity(97); |
| fb.insert_range(..3); |
| fb.insert_range(9..32); |
| fb.insert_range(37..81); |
| fb.insert_range(90..); |
| for i in 0..97 { |
| assert_eq!( |
| fb.contains(i), |
| i < 3 || 9 <= i && i < 32 || 37 <= i && i < 81 || 90 <= i |
| ); |
| } |
| assert!(!fb.contains(97)); |
| assert!(!fb.contains(127)); |
| assert!(!fb.contains(128)); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn contains_all_in_range() { |
| let mut fb = FixedBitSet::with_capacity(48); |
| fb.insert_range(..); |
| |
| fb.remove_range(..32); |
| fb.remove_range(37..); |
| |
| assert!(fb.contains_all_in_range(32..37)); |
| assert!(fb.contains_all_in_range(32..35)); |
| assert!(!fb.contains_all_in_range(32..)); |
| assert!(!fb.contains_all_in_range(..37)); |
| assert!(!fb.contains_all_in_range(..)); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn contains_any_in_range() { |
| let mut fb = FixedBitSet::with_capacity(48); |
| fb.insert_range(..); |
| |
| fb.remove_range(..32); |
| fb.remove_range(37..); |
| |
| assert!(!fb.contains_any_in_range(..32)); |
| assert!(fb.contains_any_in_range(32..37)); |
| assert!(fb.contains_any_in_range(32..35)); |
| assert!(fb.contains_any_in_range(32..)); |
| assert!(fb.contains_any_in_range(..37)); |
| assert!(!fb.contains_any_in_range(37..)); |
| assert!(fb.contains_any_in_range(..)); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn remove_range() { |
| let mut fb = FixedBitSet::with_capacity(48); |
| fb.insert_range(..); |
| |
| fb.remove_range(..32); |
| fb.remove_range(37..); |
| |
| for i in 0..48 { |
| assert_eq!(fb.contains(i), 32 <= i && i < 37); |
| } |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn set_range() { |
| let mut fb = FixedBitSet::with_capacity(48); |
| fb.insert_range(..); |
| |
| fb.set_range(..32, false); |
| fb.set_range(37.., false); |
| fb.set_range(5..9, true); |
| fb.set_range(40..40, true); |
| |
| for i in 0..48 { |
| assert_eq!(fb.contains(i), 5 <= i && i < 9 || 32 <= i && i < 37); |
| } |
| assert!(!fb.contains(48)); |
| assert!(!fb.contains(64)); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn toggle_range() { |
| let mut fb = FixedBitSet::with_capacity(40); |
| fb.insert_range(..10); |
| fb.insert_range(34..38); |
| |
| fb.toggle_range(5..12); |
| fb.toggle_range(30..); |
| |
| for i in 0..40 { |
| assert_eq!( |
| fb.contains(i), |
| i < 5 || 10 <= i && i < 12 || 30 <= i && i < 34 || 38 <= i |
| ); |
| } |
| assert!(!fb.contains(40)); |
| assert!(!fb.contains(64)); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn bitand_equal_lengths() { |
| let len = 109; |
| let a_end = 59; |
| let b_start = 23; |
| let mut a = FixedBitSet::with_capacity(len); |
| let mut b = FixedBitSet::with_capacity(len); |
| a.set_range(..a_end, true); |
| b.set_range(b_start.., true); |
| let ab = &a & &b; |
| for i in 0..b_start { |
| assert!(!ab.contains(i)); |
| } |
| for i in b_start..a_end { |
| assert!(ab.contains(i)); |
| } |
| for i in a_end..len { |
| assert!(!ab.contains(i)); |
| } |
| assert_eq!(a.len(), ab.len()); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn bitand_first_smaller() { |
| let a_len = 113; |
| let b_len = 137; |
| let len = core::cmp::min(a_len, b_len); |
| let a_end = 97; |
| let b_start = 89; |
| let mut a = FixedBitSet::with_capacity(a_len); |
| let mut b = FixedBitSet::with_capacity(b_len); |
| a.set_range(..a_end, true); |
| b.set_range(b_start.., true); |
| let ab = &a & &b; |
| for i in 0..b_start { |
| assert!(!ab.contains(i)); |
| } |
| for i in b_start..a_end { |
| assert!(ab.contains(i)); |
| } |
| for i in a_end..len { |
| assert!(!ab.contains(i)); |
| } |
| assert_eq!(a.len(), ab.len()); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn bitand_first_larger() { |
| let a_len = 173; |
| let b_len = 137; |
| let len = core::cmp::min(a_len, b_len); |
| let a_end = 107; |
| let b_start = 43; |
| let mut a = FixedBitSet::with_capacity(a_len); |
| let mut b = FixedBitSet::with_capacity(b_len); |
| a.set_range(..a_end, true); |
| b.set_range(b_start.., true); |
| let ab = &a & &b; |
| for i in 0..b_start { |
| assert!(!ab.contains(i)); |
| } |
| for i in b_start..a_end { |
| assert!(ab.contains(i)); |
| } |
| for i in a_end..len { |
| assert!(!ab.contains(i)); |
| } |
| assert_eq!(b.len(), ab.len()); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn intersection() { |
| let len = 109; |
| let a_end = 59; |
| let b_start = 23; |
| let mut a = FixedBitSet::with_capacity(len); |
| let mut b = FixedBitSet::with_capacity(len); |
| a.set_range(..a_end, true); |
| b.set_range(b_start.., true); |
| let count = a.intersection_count(&b); |
| let iterator_count = a.intersection(&b).count(); |
| let mut ab = a.intersection(&b).collect::<FixedBitSet>(); |
| |
| for i in 0..b_start { |
| assert!(!ab.contains(i)); |
| } |
| for i in b_start..a_end { |
| assert!(ab.contains(i)); |
| } |
| for i in a_end..len { |
| assert!(!ab.contains(i)); |
| } |
| |
| a.intersect_with(&b); |
| // intersection + collect produces the same results but with a shorter length. |
| ab.grow(a.len()); |
| assert_eq!( |
| ab, a, |
| "intersection and intersect_with produce the same results" |
| ); |
| assert_eq!( |
| ab.count_ones(..), |
| count, |
| "intersection and intersection_count produce the same results" |
| ); |
| assert_eq!( |
| count, iterator_count, |
| "intersection and intersection_count produce the same results" |
| ); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn union() { |
| let a_len = 173; |
| let b_len = 137; |
| let a_start = 139; |
| let b_end = 107; |
| let mut a = FixedBitSet::with_capacity(a_len); |
| let mut b = FixedBitSet::with_capacity(b_len); |
| a.set_range(a_start.., true); |
| b.set_range(..b_end, true); |
| let count = a.union_count(&b); |
| let iterator_count = a.union(&b).count(); |
| let ab = a.union(&b).collect::<FixedBitSet>(); |
| for i in a_start..a_len { |
| assert!(ab.contains(i)); |
| } |
| for i in 0..b_end { |
| assert!(ab.contains(i)); |
| } |
| for i in b_end..a_start { |
| assert!(!ab.contains(i)); |
| } |
| |
| a.union_with(&b); |
| assert_eq!(ab, a, "union and union_with produce the same results"); |
| assert_eq!( |
| count, |
| ab.count_ones(..), |
| "union and union_count produce the same results" |
| ); |
| assert_eq!( |
| count, iterator_count, |
| "union and union_count produce the same results" |
| ); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn difference() { |
| let a_len = 83; |
| let b_len = 151; |
| let a_start = 0; |
| let a_end = 79; |
| let b_start = 53; |
| let mut a = FixedBitSet::with_capacity(a_len); |
| let mut b = FixedBitSet::with_capacity(b_len); |
| a.set_range(a_start..a_end, true); |
| b.set_range(b_start..b_len, true); |
| let count = a.difference_count(&b); |
| let iterator_count = a.difference(&b).count(); |
| let mut a_diff_b = a.difference(&b).collect::<FixedBitSet>(); |
| for i in a_start..b_start { |
| assert!(a_diff_b.contains(i)); |
| } |
| for i in b_start..b_len { |
| assert!(!a_diff_b.contains(i)); |
| } |
| |
| a.difference_with(&b); |
| // difference + collect produces the same results but with a shorter length. |
| a_diff_b.grow(a.len()); |
| assert_eq!( |
| a_diff_b, a, |
| "difference and difference_with produce the same results" |
| ); |
| assert_eq!( |
| a_diff_b.count_ones(..), |
| count, |
| "difference and difference_count produce the same results" |
| ); |
| assert_eq!( |
| count, iterator_count, |
| "intersection and intersection_count produce the same results" |
| ); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn symmetric_difference() { |
| let a_len = 83; |
| let b_len = 151; |
| let a_start = 47; |
| let a_end = 79; |
| let b_start = 53; |
| let mut a = FixedBitSet::with_capacity(a_len); |
| let mut b = FixedBitSet::with_capacity(b_len); |
| a.set_range(a_start..a_end, true); |
| b.set_range(b_start..b_len, true); |
| let count = a.symmetric_difference_count(&b); |
| let iterator_count = a.symmetric_difference(&b).count(); |
| let a_sym_diff_b = a.symmetric_difference(&b).collect::<FixedBitSet>(); |
| for i in 0..a_start { |
| assert!(!a_sym_diff_b.contains(i)); |
| } |
| for i in a_start..b_start { |
| assert!(a_sym_diff_b.contains(i)); |
| } |
| for i in b_start..a_end { |
| assert!(!a_sym_diff_b.contains(i)); |
| } |
| for i in a_end..b_len { |
| assert!(a_sym_diff_b.contains(i)); |
| } |
| |
| a.symmetric_difference_with(&b); |
| assert_eq!( |
| a_sym_diff_b, a, |
| "symmetric_difference and _with produce the same results" |
| ); |
| assert_eq!( |
| a_sym_diff_b.count_ones(..), |
| count, |
| "symmetric_difference and _count produce the same results" |
| ); |
| assert_eq!( |
| count, iterator_count, |
| "symmetric_difference and _count produce the same results" |
| ); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn bitor_equal_lengths() { |
| let len = 109; |
| let a_start = 17; |
| let a_end = 23; |
| let b_start = 19; |
| let b_end = 59; |
| let mut a = FixedBitSet::with_capacity(len); |
| let mut b = FixedBitSet::with_capacity(len); |
| a.set_range(a_start..a_end, true); |
| b.set_range(b_start..b_end, true); |
| let ab = &a | &b; |
| for i in 0..a_start { |
| assert!(!ab.contains(i)); |
| } |
| for i in a_start..b_end { |
| assert!(ab.contains(i)); |
| } |
| for i in b_end..len { |
| assert!(!ab.contains(i)); |
| } |
| assert_eq!(ab.len(), len); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn bitor_first_smaller() { |
| let a_len = 113; |
| let b_len = 137; |
| let a_end = 89; |
| let b_start = 97; |
| let mut a = FixedBitSet::with_capacity(a_len); |
| let mut b = FixedBitSet::with_capacity(b_len); |
| a.set_range(..a_end, true); |
| b.set_range(b_start.., true); |
| let ab = &a | &b; |
| for i in 0..a_end { |
| assert!(ab.contains(i)); |
| } |
| for i in a_end..b_start { |
| assert!(!ab.contains(i)); |
| } |
| for i in b_start..b_len { |
| assert!(ab.contains(i)); |
| } |
| assert_eq!(b_len, ab.len()); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn bitor_first_larger() { |
| let a_len = 173; |
| let b_len = 137; |
| let a_start = 139; |
| let b_end = 107; |
| let mut a = FixedBitSet::with_capacity(a_len); |
| let mut b = FixedBitSet::with_capacity(b_len); |
| a.set_range(a_start.., true); |
| b.set_range(..b_end, true); |
| let ab = &a | &b; |
| for i in a_start..a_len { |
| assert!(ab.contains(i)); |
| } |
| for i in 0..b_end { |
| assert!(ab.contains(i)); |
| } |
| for i in b_end..a_start { |
| assert!(!ab.contains(i)); |
| } |
| assert_eq!(a_len, ab.len()); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn bitxor_equal_lengths() { |
| let len = 109; |
| let a_end = 59; |
| let b_start = 23; |
| let mut a = FixedBitSet::with_capacity(len); |
| let mut b = FixedBitSet::with_capacity(len); |
| a.set_range(..a_end, true); |
| b.set_range(b_start.., true); |
| let ab = &a ^ &b; |
| for i in 0..b_start { |
| assert!(ab.contains(i)); |
| } |
| for i in b_start..a_end { |
| assert!(!ab.contains(i)); |
| } |
| for i in a_end..len { |
| assert!(ab.contains(i)); |
| } |
| assert_eq!(a.len(), ab.len()); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn bitxor_first_smaller() { |
| let a_len = 113; |
| let b_len = 137; |
| let len = core::cmp::max(a_len, b_len); |
| let a_end = 97; |
| let b_start = 89; |
| let mut a = FixedBitSet::with_capacity(a_len); |
| let mut b = FixedBitSet::with_capacity(b_len); |
| a.set_range(..a_end, true); |
| b.set_range(b_start.., true); |
| let ab = &a ^ &b; |
| for i in 0..b_start { |
| assert!(ab.contains(i)); |
| } |
| for i in b_start..a_end { |
| assert!(!ab.contains(i)); |
| } |
| for i in a_end..len { |
| assert!(ab.contains(i)); |
| } |
| assert_eq!(b.len(), ab.len()); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn bitxor_first_larger() { |
| let a_len = 173; |
| let b_len = 137; |
| let len = core::cmp::max(a_len, b_len); |
| let a_end = 107; |
| let b_start = 43; |
| let mut a = FixedBitSet::with_capacity(a_len); |
| let mut b = FixedBitSet::with_capacity(b_len); |
| a.set_range(..a_end, true); |
| b.set_range(b_start.., true); |
| let ab = &a ^ &b; |
| for i in 0..b_start { |
| assert!(ab.contains(i)); |
| } |
| for i in b_start..a_end { |
| assert!(!ab.contains(i)); |
| } |
| for i in a_end..b_len { |
| assert!(ab.contains(i)); |
| } |
| for i in b_len..len { |
| assert!(!ab.contains(i)); |
| } |
| assert_eq!(a.len(), ab.len()); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn bitand_assign_shorter() { |
| let a_ones: Vec<usize> = vec![2, 3, 7, 19, 31, 32, 37, 41, 43, 47, 71, 73, 101]; |
| let b_ones: Vec<usize> = vec![2, 7, 8, 11, 23, 31, 32]; |
| let a_and_b: Vec<usize> = vec![2, 7, 31, 32]; |
| let mut a = a_ones.iter().cloned().collect::<FixedBitSet>(); |
| let b = b_ones.iter().cloned().collect::<FixedBitSet>(); |
| a &= b; |
| let res = a.ones().collect::<Vec<usize>>(); |
| |
| assert!(res == a_and_b); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn bitand_assign_longer() { |
| let a_ones: Vec<usize> = vec![2, 7, 8, 11, 23, 31, 32]; |
| let b_ones: Vec<usize> = vec![2, 3, 7, 19, 31, 32, 37, 41, 43, 47, 71, 73, 101]; |
| let a_and_b: Vec<usize> = vec![2, 7, 31, 32]; |
| let mut a = a_ones.iter().cloned().collect::<FixedBitSet>(); |
| let b = b_ones.iter().cloned().collect::<FixedBitSet>(); |
| a &= b; |
| let res = a.ones().collect::<Vec<usize>>(); |
| assert!(res == a_and_b); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn bitor_assign_shorter() { |
| let a_ones: Vec<usize> = vec![2, 3, 7, 19, 31, 32, 37, 41, 43, 47, 71, 73, 101]; |
| let b_ones: Vec<usize> = vec![2, 7, 8, 11, 23, 31, 32]; |
| let a_or_b: Vec<usize> = vec![2, 3, 7, 8, 11, 19, 23, 31, 32, 37, 41, 43, 47, 71, 73, 101]; |
| let mut a = a_ones.iter().cloned().collect::<FixedBitSet>(); |
| let b = b_ones.iter().cloned().collect::<FixedBitSet>(); |
| a |= b; |
| let res = a.ones().collect::<Vec<usize>>(); |
| assert!(res == a_or_b); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn bitor_assign_longer() { |
| let a_ones: Vec<usize> = vec![2, 7, 8, 11, 23, 31, 32]; |
| let b_ones: Vec<usize> = vec![2, 3, 7, 19, 31, 32, 37, 41, 43, 47, 71, 73, 101]; |
| let a_or_b: Vec<usize> = vec![2, 3, 7, 8, 11, 19, 23, 31, 32, 37, 41, 43, 47, 71, 73, 101]; |
| let mut a = a_ones.iter().cloned().collect::<FixedBitSet>(); |
| let b = b_ones.iter().cloned().collect::<FixedBitSet>(); |
| a |= b; |
| let res = a.ones().collect::<Vec<usize>>(); |
| assert_eq!(res, a_or_b); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn bitxor_assign_shorter() { |
| let a_ones: Vec<usize> = vec![2, 3, 7, 19, 31, 32, 37, 41, 43, 47, 71, 73, 101]; |
| let b_ones: Vec<usize> = vec![2, 7, 8, 11, 23, 31, 32]; |
| let a_xor_b: Vec<usize> = vec![3, 8, 11, 19, 23, 37, 41, 43, 47, 71, 73, 101]; |
| let mut a = a_ones.iter().cloned().collect::<FixedBitSet>(); |
| let b = b_ones.iter().cloned().collect::<FixedBitSet>(); |
| a ^= b; |
| let res = a.ones().collect::<Vec<usize>>(); |
| assert!(res == a_xor_b); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn bitxor_assign_longer() { |
| let a_ones: Vec<usize> = vec![2, 7, 8, 11, 23, 31, 32]; |
| let b_ones: Vec<usize> = vec![2, 3, 7, 19, 31, 32, 37, 41, 43, 47, 71, 73, 101]; |
| let a_xor_b: Vec<usize> = vec![3, 8, 11, 19, 23, 37, 41, 43, 47, 71, 73, 101]; |
| let mut a = a_ones.iter().cloned().collect::<FixedBitSet>(); |
| let b = b_ones.iter().cloned().collect::<FixedBitSet>(); |
| a ^= b; |
| let res = a.ones().collect::<Vec<usize>>(); |
| assert!(res == a_xor_b); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn op_assign_ref() { |
| let mut a = FixedBitSet::with_capacity(8); |
| let b = FixedBitSet::with_capacity(8); |
| |
| //check that all assign type operators work on references |
| a &= &b; |
| a |= &b; |
| a ^= &b; |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn subset_superset_shorter() { |
| let a_ones: Vec<usize> = vec![7, 31, 32, 63]; |
| let b_ones: Vec<usize> = vec![2, 7, 19, 31, 32, 37, 41, 43, 47, 63, 73, 101]; |
| let mut a = a_ones.iter().cloned().collect::<FixedBitSet>(); |
| let b = b_ones.iter().cloned().collect::<FixedBitSet>(); |
| assert!(a.is_subset(&b) && b.is_superset(&a)); |
| a.insert(14); |
| assert!(!a.is_subset(&b) && !b.is_superset(&a)); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn subset_superset_longer() { |
| let a_len = 153; |
| let b_len = 75; |
| let a_ones: Vec<usize> = vec![7, 31, 32, 63]; |
| let b_ones: Vec<usize> = vec![2, 7, 19, 31, 32, 37, 41, 43, 47, 63, 73]; |
| let mut a = FixedBitSet::with_capacity(a_len); |
| let mut b = FixedBitSet::with_capacity(b_len); |
| a.extend(a_ones.iter().cloned()); |
| b.extend(b_ones.iter().cloned()); |
| assert!(a.is_subset(&b) && b.is_superset(&a)); |
| a.insert(100); |
| assert!(!a.is_subset(&b) && !b.is_superset(&a)); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn is_disjoint_first_shorter() { |
| let a_len = 75; |
| let b_len = 153; |
| let a_ones: Vec<usize> = vec![2, 19, 32, 37, 41, 43, 47, 73]; |
| let b_ones: Vec<usize> = vec![7, 23, 31, 63, 124]; |
| let mut a = FixedBitSet::with_capacity(a_len); |
| let mut b = FixedBitSet::with_capacity(b_len); |
| a.extend(a_ones.iter().cloned()); |
| b.extend(b_ones.iter().cloned()); |
| assert!(a.is_disjoint(&b)); |
| a.insert(63); |
| assert!(!a.is_disjoint(&b)); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn is_disjoint_first_longer() { |
| let a_ones: Vec<usize> = vec![2, 19, 32, 37, 41, 43, 47, 73, 101]; |
| let b_ones: Vec<usize> = vec![7, 23, 31, 63]; |
| let a = a_ones.iter().cloned().collect::<FixedBitSet>(); |
| let mut b = b_ones.iter().cloned().collect::<FixedBitSet>(); |
| assert!(a.is_disjoint(&b)); |
| b.insert(2); |
| assert!(!a.is_disjoint(&b)); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn extend_on_empty() { |
| let items: Vec<usize> = vec![2, 3, 5, 7, 11, 13, 17, 19, 23, 27, 29, 31, 37, 167]; |
| let mut fbs = FixedBitSet::with_capacity(0); |
| fbs.extend(items.iter().cloned()); |
| let ones = fbs.ones().collect::<Vec<usize>>(); |
| assert!(ones == items); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn extend() { |
| let items: Vec<usize> = vec![2, 3, 5, 7, 11, 13, 17, 19, 23, 27, 29, 31, 37, 167]; |
| let mut fbs = FixedBitSet::with_capacity(168); |
| let new: Vec<usize> = vec![7, 37, 67, 137]; |
| for i in &new { |
| fbs.put(*i); |
| } |
| |
| fbs.extend(items.iter().cloned()); |
| |
| let ones = fbs.ones().collect::<Vec<usize>>(); |
| let expected = { |
| let mut tmp = items.clone(); |
| tmp.extend(new); |
| tmp.sort(); |
| tmp.dedup(); |
| tmp |
| }; |
| |
| assert_eq!(ones, expected); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn from_iterator() { |
| let items: Vec<usize> = vec![0, 2, 4, 6, 8]; |
| let fb = items.iter().cloned().collect::<FixedBitSet>(); |
| for i in items { |
| assert!(fb.contains(i)); |
| } |
| for i in vec![1, 3, 5, 7] { |
| assert!(!fb.contains(i)); |
| } |
| assert_eq!(fb.len(), 9); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn from_iterator_ones() { |
| let len = 257; |
| let mut fb = FixedBitSet::with_capacity(len); |
| for i in (0..len).filter(|i| i % 7 == 0) { |
| fb.put(i); |
| } |
| fb.put(len - 1); |
| let dup = fb.ones().collect::<FixedBitSet>(); |
| |
| assert_eq!(fb.len(), dup.len()); |
| assert_eq!( |
| fb.ones().collect::<Vec<usize>>(), |
| dup.ones().collect::<Vec<usize>>() |
| ); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn zeroes() { |
| let len = 232; |
| let mut fb = FixedBitSet::with_capacity(len); |
| for i in (0..len).filter(|i| i % 7 == 0) { |
| fb.insert(i); |
| } |
| let zeroes = fb.zeroes().collect::<Vec<usize>>(); |
| |
| assert_eq!( |
| zeroes, |
| vec![ |
| 1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 15, 16, 17, 18, 19, 20, 22, 23, 24, 25, 26, 27, |
| 29, 30, 31, 32, 33, 34, 36, 37, 38, 39, 40, 41, 43, 44, 45, 46, 47, 48, 50, 51, 52, 53, |
| 54, 55, 57, 58, 59, 60, 61, 62, 64, 65, 66, 67, 68, 69, 71, 72, 73, 74, 75, 76, 78, 79, |
| 80, 81, 82, 83, 85, 86, 87, 88, 89, 90, 92, 93, 94, 95, 96, 97, 99, 100, 101, 102, 103, |
| 104, 106, 107, 108, 109, 110, 111, 113, 114, 115, 116, 117, 118, 120, 121, 122, 123, |
| 124, 125, 127, 128, 129, 130, 131, 132, 134, 135, 136, 137, 138, 139, 141, 142, 143, |
| 144, 145, 146, 148, 149, 150, 151, 152, 153, 155, 156, 157, 158, 159, 160, 162, 163, |
| 164, 165, 166, 167, 169, 170, 171, 172, 173, 174, 176, 177, 178, 179, 180, 181, 183, |
| 184, 185, 186, 187, 188, 190, 191, 192, 193, 194, 195, 197, 198, 199, 200, 201, 202, |
| 204, 205, 206, 207, 208, 209, 211, 212, 213, 214, 215, 216, 218, 219, 220, 221, 222, |
| 223, 225, 226, 227, 228, 229, 230 |
| ] |
| ); |
| } |
| |
| #[cfg(feature = "std")] |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn binary_trait() { |
| let items: Vec<usize> = vec![1, 5, 7, 10, 14, 15]; |
| let fb = items.iter().cloned().collect::<FixedBitSet>(); |
| |
| assert_eq!(alloc::format!("{:b}", fb), "0100010100100011"); |
| assert_eq!(alloc::format!("{:#b}", fb), "0b0100010100100011"); |
| } |
| |
| #[cfg(feature = "std")] |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn display_trait() { |
| let len = 8; |
| let mut fb = FixedBitSet::with_capacity(len); |
| |
| fb.put(4); |
| fb.put(2); |
| |
| assert_eq!(alloc::format!("{}", fb), "00101000"); |
| assert_eq!(alloc::format!("{:#}", fb), "0b00101000"); |
| } |
| |
| // TODO: Rewite this test to be platform agnostic. |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| #[cfg(all(feature = "serde", target_pointer_width = "64"))] |
| fn test_serialize() { |
| let mut fb = FixedBitSet::with_capacity(10); |
| fb.put(2); |
| fb.put(3); |
| fb.put(6); |
| fb.put(8); |
| let serialized = serde_json::to_string(&fb).unwrap(); |
| assert_eq!(r#"{"length":10,"data":[76,1,0,0,0,0,0,0]}"#, serialized); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn test_is_clear() { |
| let mut fb = FixedBitSet::with_capacity(0); |
| assert!(fb.is_clear()); |
| |
| fb.grow(1); |
| assert!(fb.is_clear()); |
| |
| fb.put(0); |
| assert!(!fb.is_clear()); |
| |
| fb.grow(42); |
| fb.clear(); |
| assert!(fb.is_clear()); |
| |
| fb.put(17); |
| fb.put(19); |
| assert!(!fb.is_clear()); |
| } |
| |
| #[test] |
| #[cfg_attr(target_family = "wasm", wasm_bindgen_test)] |
| fn test_is_full() { |
| let mut fb = FixedBitSet::with_capacity(0); |
| assert!(fb.is_full()); |
| |
| fb.grow(1); |
| assert!(!fb.is_full()); |
| |
| fb.put(0); |
| assert!(fb.is_full()); |
| |
| fb.grow(42); |
| fb.clear(); |
| assert!(!fb.is_full()); |
| |
| fb.put(17); |
| fb.put(19); |
| assert!(!fb.is_full()); |
| |
| fb.insert_range(..); |
| assert!(fb.is_full()); |
| } |
| |
| #[test] |
| fn clone() { |
| let mut fb = FixedBitSet::with_capacity(10000); |
| fb.set(11, true); |
| fb.set(12, true); |
| fb.set(7, true); |
| fb.set(35, true); |
| fb.set(40, true); |
| fb.set(77, true); |
| fb.set(95, true); |
| fb.set(50, true); |
| fb.set(99, true); |
| |
| let fb_clone = fb.clone(); |
| let mut fb_clone_from_smaller = FixedBitSet::with_capacity(1000000); |
| let mut fb_clone_from_same = FixedBitSet::with_capacity(10000); |
| let mut fb_clone_from_bigger = FixedBitSet::with_capacity(100); |
| fb_clone_from_smaller.clone_from(&fb); |
| fb_clone_from_same.clone_from(&fb); |
| fb_clone_from_bigger.clone_from(&fb); |
| |
| assert_eq!(&fb, &fb_clone); |
| assert_eq!(&fb, &fb_clone_from_smaller); |
| assert_eq!(&fb, &fb_clone_from_same); |
| assert_eq!(&fb, &fb_clone_from_bigger); |
| } |