1 use fixedbitset::*;
2
3 #[cfg(target_family = "wasm")]
4 use wasm_bindgen_test::*;
5 #[cfg(target_family = "wasm")]
6 wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);
7
8 extern crate alloc;
9
10 const BITS: usize = core::mem::size_of::<Block>() * 8;
11
12 #[test]
13 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
it_works()14 fn it_works() {
15 const N: usize = 50;
16 let mut fb = FixedBitSet::with_capacity(N);
17
18 for i in 0..(N + 10) {
19 assert_eq!(fb.contains(i), false);
20 }
21
22 fb.insert(10);
23 fb.set(11, false);
24 fb.set(12, false);
25 fb.set(12, true);
26 fb.set(N - 1, true);
27
28 assert!(fb.contains(10));
29 assert!(!fb.contains(11));
30 assert!(fb.contains(12));
31 assert!(fb.contains(N - 1));
32 for i in 0..N {
33 let contain = i == 10 || i == 12 || i == N - 1;
34 assert_eq!(contain, fb[i]);
35 }
36
37 fb.clear();
38 }
39
40 #[test]
41 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
with_blocks()42 fn with_blocks() {
43 let fb = FixedBitSet::with_capacity_and_blocks(50, vec![8, 0]);
44 assert!(fb.contains(3));
45
46 let ones: Vec<_> = fb.ones().collect();
47 assert_eq!(ones.len(), 1);
48
49 let ones: Vec<_> = fb.ones().rev().collect();
50 assert_eq!(ones.len(), 1);
51
52 let ones: Vec<_> = fb.ones().rev().alternate().collect();
53 assert_eq!(ones.len(), 1);
54 }
55
56 #[test]
57 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
with_blocks_too_small()58 fn with_blocks_too_small() {
59 let mut fb = FixedBitSet::with_capacity_and_blocks(500, vec![8, 0]);
60 fb.insert(400);
61 assert!(fb.contains(400));
62 }
63
64 #[test]
65 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
with_blocks_too_big()66 fn with_blocks_too_big() {
67 let fb = FixedBitSet::with_capacity_and_blocks(1, vec![8]);
68
69 // since capacity is 1, 3 shouldn't be set here
70 assert!(!fb.contains(3));
71 }
72
73 #[test]
74 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
with_blocks_too_big_range_check()75 fn with_blocks_too_big_range_check() {
76 let fb = FixedBitSet::with_capacity_and_blocks(1, vec![0xff]);
77
78 // since capacity is 1, only 0 should be set
79 assert!(fb.contains(0));
80 for i in 1..0xff {
81 assert!(!fb.contains(i));
82 }
83 }
84
85 #[test]
86 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
grow()87 fn grow() {
88 let mut fb = FixedBitSet::with_capacity(48);
89 for i in 0..fb.len() {
90 fb.set(i, true);
91 }
92
93 let old_len = fb.len();
94 fb.grow(72);
95 for j in 0..fb.len() {
96 assert_eq!(fb.contains(j), j < old_len);
97 }
98 fb.set(64, true);
99 assert!(fb.contains(64));
100 }
101
102 #[test]
103 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
grow_and_insert()104 fn grow_and_insert() {
105 let mut fb = FixedBitSet::default();
106 for i in 0..100 {
107 if i % 3 == 0 {
108 fb.grow_and_insert(i);
109 }
110 }
111
112 assert_eq!(fb.count_ones(..), 34);
113 }
114
115 #[test]
116 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
test_toggle()117 fn test_toggle() {
118 let mut fb = FixedBitSet::with_capacity(16);
119 fb.toggle(1);
120 fb.put(2);
121 fb.toggle(2);
122 fb.put(3);
123 assert!(fb.contains(1));
124 assert!(!fb.contains(2));
125 assert!(fb.contains(3));
126 }
127
128 #[test]
129 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
copy_bit()130 fn copy_bit() {
131 let mut fb = FixedBitSet::with_capacity(48);
132 for i in 0..fb.len() {
133 fb.set(i, true);
134 }
135 fb.set(42, false);
136 fb.copy_bit(42, 2);
137 assert!(!fb.contains(42));
138 assert!(!fb.contains(2));
139 assert!(fb.contains(1));
140 fb.copy_bit(1, 42);
141 assert!(fb.contains(42));
142 fb.copy_bit(1024, 42);
143 assert!(!fb[42]);
144 }
145
146 #[test]
147 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
count_ones()148 fn count_ones() {
149 let mut fb = FixedBitSet::with_capacity(100);
150 fb.set(11, true);
151 fb.set(12, true);
152 fb.set(7, true);
153 fb.set(35, true);
154 fb.set(40, true);
155 fb.set(77, true);
156 fb.set(95, true);
157 fb.set(50, true);
158 fb.set(99, true);
159 assert_eq!(fb.count_ones(..7), 0);
160 assert_eq!(fb.count_ones(..8), 1);
161 assert_eq!(fb.count_ones(..11), 1);
162 assert_eq!(fb.count_ones(..12), 2);
163 assert_eq!(fb.count_ones(..13), 3);
164 assert_eq!(fb.count_ones(..35), 3);
165 assert_eq!(fb.count_ones(..36), 4);
166 assert_eq!(fb.count_ones(..40), 4);
167 assert_eq!(fb.count_ones(..41), 5);
168 assert_eq!(fb.count_ones(50..), 4);
169 assert_eq!(fb.count_ones(70..95), 1);
170 assert_eq!(fb.count_ones(70..96), 2);
171 assert_eq!(fb.count_ones(70..99), 2);
172 assert_eq!(fb.count_ones(..), 9);
173 assert_eq!(fb.count_ones(0..100), 9);
174 assert_eq!(fb.count_ones(0..0), 0);
175 assert_eq!(fb.count_ones(100..100), 0);
176 assert_eq!(fb.count_ones(7..), 9);
177 assert_eq!(fb.count_ones(8..), 8);
178 }
179
180 #[test]
181 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
count_zeroes()182 fn count_zeroes() {
183 let mut fb = FixedBitSet::with_capacity(100);
184 fb.set(11, true);
185 fb.set(12, true);
186 fb.set(7, true);
187 fb.set(35, true);
188 fb.set(40, true);
189 fb.set(77, true);
190 fb.set(95, true);
191 fb.set(50, true);
192 fb.set(99, true);
193 assert_eq!(fb.count_zeroes(..7), 7);
194 assert_eq!(fb.count_zeroes(..8), 7);
195 assert_eq!(fb.count_zeroes(..11), 10);
196 assert_eq!(fb.count_zeroes(..12), 10);
197 assert_eq!(fb.count_zeroes(..13), 10);
198 assert_eq!(fb.count_zeroes(..35), 32);
199 assert_eq!(fb.count_zeroes(..36), 32);
200 assert_eq!(fb.count_zeroes(..40), 36);
201 assert_eq!(fb.count_zeroes(..41), 36);
202 assert_eq!(fb.count_zeroes(50..), 46);
203 assert_eq!(fb.count_zeroes(70..95), 24);
204 assert_eq!(fb.count_zeroes(70..96), 24);
205 assert_eq!(fb.count_zeroes(70..99), 27);
206 assert_eq!(fb.count_zeroes(..), 91);
207 assert_eq!(fb.count_zeroes(0..100), 91);
208 assert_eq!(fb.count_zeroes(0..0), 0);
209 assert_eq!(fb.count_zeroes(100..100), 0);
210 assert_eq!(fb.count_zeroes(7..), 84);
211 assert_eq!(fb.count_zeroes(8..), 84);
212 }
213
214 #[test]
215 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
minimum()216 fn minimum() {
217 let mut fb = FixedBitSet::with_capacity(100);
218 assert_eq!(fb.minimum(), None);
219 fb.set(95, true);
220 assert_eq!(fb.minimum(), Some(95));
221 fb.set(77, true);
222 assert_eq!(fb.minimum(), Some(77));
223 fb.set(12, true);
224 assert_eq!(fb.minimum(), Some(12));
225 fb.set(40, true);
226 assert_eq!(fb.minimum(), Some(12));
227 fb.set(35, true);
228 assert_eq!(fb.minimum(), Some(12));
229 fb.set(11, true);
230 assert_eq!(fb.minimum(), Some(11));
231 fb.set(7, true);
232 assert_eq!(fb.minimum(), Some(7));
233 fb.set(50, true);
234 assert_eq!(fb.minimum(), Some(7));
235 fb.set(99, true);
236 assert_eq!(fb.minimum(), Some(7));
237 fb.clear();
238 assert_eq!(fb.minimum(), None);
239 }
240
241 #[test]
242 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
maximum()243 fn maximum() {
244 let mut fb = FixedBitSet::with_capacity(100);
245 assert_eq!(fb.maximum(), None);
246 fb.set(11, true);
247 assert_eq!(fb.maximum(), Some(11));
248 fb.set(12, true);
249 assert_eq!(fb.maximum(), Some(12));
250 fb.set(7, true);
251 assert_eq!(fb.maximum(), Some(12));
252 fb.set(40, true);
253 assert_eq!(fb.maximum(), Some(40));
254 fb.set(35, true);
255 assert_eq!(fb.maximum(), Some(40));
256 fb.set(95, true);
257 assert_eq!(fb.maximum(), Some(95));
258 fb.set(50, true);
259 assert_eq!(fb.maximum(), Some(95));
260 fb.set(77, true);
261 assert_eq!(fb.maximum(), Some(95));
262 fb.set(99, true);
263 assert_eq!(fb.maximum(), Some(99));
264 fb.clear();
265 assert_eq!(fb.maximum(), None);
266 }
267
268 /* Helper for testing double ended iterator */
269 #[cfg(test)]
270 struct Alternating<I> {
271 iter: I,
272 front: bool,
273 }
274
275 #[cfg(test)]
276 impl<I: Iterator + DoubleEndedIterator> Iterator for Alternating<I> {
277 type Item = I::Item;
278
size_hint(&self) -> (usize, Option<usize>)279 fn size_hint(&self) -> (usize, Option<usize>) {
280 self.iter.size_hint()
281 }
next(&mut self) -> Option<Self::Item>282 fn next(&mut self) -> Option<Self::Item> {
283 if self.front {
284 self.front = false;
285 self.iter.next()
286 } else {
287 self.front = true;
288 self.iter.next_back()
289 }
290 }
291 }
292 #[cfg(test)]
293 trait AlternatingExt: Iterator + DoubleEndedIterator + Sized {
alternate(self) -> Alternating<Self>294 fn alternate(self) -> Alternating<Self> {
295 Alternating {
296 iter: self,
297 front: true,
298 }
299 }
300 }
301
302 #[cfg(test)]
303 impl<I: Iterator + DoubleEndedIterator> AlternatingExt for I {}
304
305 #[test]
306 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
ones()307 fn ones() {
308 let mut fb = FixedBitSet::with_capacity(100);
309 fb.set(11, true);
310 fb.set(12, true);
311 fb.set(7, true);
312 fb.set(35, true);
313 fb.set(40, true);
314 fb.set(77, true);
315 fb.set(95, true);
316 fb.set(50, true);
317 fb.set(99, true);
318
319 let ones: Vec<_> = fb.ones().collect();
320 let ones_rev: Vec<_> = fb.ones().rev().collect();
321 let ones_alternating: Vec<_> = fb.ones().alternate().collect();
322
323 let mut known_result = vec![7, 11, 12, 35, 40, 50, 77, 95, 99];
324
325 assert_eq!(known_result, ones);
326 known_result.reverse();
327 assert_eq!(known_result, ones_rev);
328 let known_result: Vec<_> = known_result.into_iter().rev().alternate().collect();
329 assert_eq!(known_result, ones_alternating);
330 }
331
332 #[test]
333 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
into_ones()334 fn into_ones() {
335 fn create() -> FixedBitSet {
336 let mut fb = FixedBitSet::with_capacity(100);
337 fb.set(11, true);
338 fb.set(12, true);
339 fb.set(7, true);
340 fb.set(35, true);
341 fb.set(40, true);
342 fb.set(77, true);
343 fb.set(95, true);
344 fb.set(50, true);
345 fb.set(99, true);
346 fb
347 }
348
349 let ones: Vec<_> = create().into_ones().collect();
350 let ones_rev: Vec<_> = create().into_ones().rev().collect();
351 let ones_alternating: Vec<_> = create().into_ones().alternate().collect();
352
353 let mut known_result = vec![7, 11, 12, 35, 40, 50, 77, 95, 99];
354
355 assert_eq!(known_result, ones);
356 known_result.reverse();
357 assert_eq!(known_result, ones_rev);
358 let known_result: Vec<_> = known_result.into_iter().rev().alternate().collect();
359 assert_eq!(known_result, ones_alternating);
360 }
361
362 #[test]
363 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
size_hint()364 fn size_hint() {
365 let iters = if cfg!(miri) { 250 } else { 1000 };
366 for s in 0..iters {
367 let mut bitset = FixedBitSet::with_capacity(s);
368 bitset.insert_range(..);
369 let mut t = s;
370 let mut iter = bitset.ones().rev();
371 loop {
372 match iter.next() {
373 None => break,
374 Some(_) => {
375 t -= 1;
376 assert!(iter.size_hint().1.unwrap() >= t);
377 // factor two, because we have first block and last block
378 assert!(iter.size_hint().1.unwrap() <= t + 2 * BITS);
379 }
380 }
381 }
382 assert_eq!(t, 0);
383 }
384 }
385
386 #[test]
387 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
size_hint_alternate()388 fn size_hint_alternate() {
389 let iters = if cfg!(miri) { 250 } else { 1000 };
390 for s in 0..iters {
391 let mut bitset = FixedBitSet::with_capacity(s);
392 bitset.insert_range(..);
393 let mut t = s;
394 extern crate std;
395 let mut iter = bitset.ones().alternate();
396 loop {
397 match iter.next() {
398 None => break,
399 Some(_) => {
400 t -= 1;
401 assert!(iter.size_hint().1.unwrap() >= t);
402 assert!(iter.size_hint().1.unwrap() <= t + 3 * BITS);
403 }
404 }
405 }
406 assert_eq!(t, 0);
407 }
408 }
409
410 #[test]
411 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
iter_ones_range()412 fn iter_ones_range() {
413 fn test_range(from: usize, to: usize, capa: usize) {
414 assert!(to <= capa);
415 let mut fb = FixedBitSet::with_capacity(capa);
416 for i in from..to {
417 fb.insert(i);
418 }
419 let ones: Vec<_> = fb.ones().collect();
420 let expected: Vec<_> = (from..to).collect();
421 let ones_rev: Vec<_> = fb.ones().rev().collect();
422 let expected_rev: Vec<_> = (from..to).rev().collect();
423 let ones_rev_alt: Vec<_> = fb.ones().rev().alternate().collect();
424 let expected_rev_alt: Vec<_> = (from..to).rev().alternate().collect();
425 assert_eq!(expected, ones);
426 assert_eq!(expected_rev, ones_rev);
427 assert_eq!(expected_rev_alt, ones_rev_alt);
428 }
429
430 for i in 0..100 {
431 test_range(i, 100, 100);
432 test_range(0, i, 100);
433 }
434 }
435
436 #[should_panic]
437 #[test]
438 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
count_ones_oob()439 fn count_ones_oob() {
440 let fb = FixedBitSet::with_capacity(100);
441 fb.count_ones(90..101);
442 }
443
444 #[should_panic]
445 #[test]
446 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
count_ones_negative_range()447 fn count_ones_negative_range() {
448 let fb = FixedBitSet::with_capacity(100);
449 fb.count_ones(90..80);
450 }
451
452 #[test]
453 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
count_ones_panic()454 fn count_ones_panic() {
455 let iters = if cfg!(miri) { 48 } else { 128 };
456 for i in 1..iters {
457 let fb = FixedBitSet::with_capacity(i);
458 for j in 0..fb.len() + 1 {
459 for k in j..fb.len() + 1 {
460 assert_eq!(fb.count_ones(j..k), 0);
461 }
462 }
463 }
464 }
465
466 #[test]
467 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
default()468 fn default() {
469 let fb = FixedBitSet::default();
470 assert_eq!(fb.len(), 0);
471 }
472
473 #[test]
474 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
insert_range()475 fn insert_range() {
476 let mut fb = FixedBitSet::with_capacity(97);
477 fb.insert_range(..3);
478 fb.insert_range(9..32);
479 fb.insert_range(37..81);
480 fb.insert_range(90..);
481 for i in 0..97 {
482 assert_eq!(
483 fb.contains(i),
484 i < 3 || 9 <= i && i < 32 || 37 <= i && i < 81 || 90 <= i
485 );
486 }
487 assert!(!fb.contains(97));
488 assert!(!fb.contains(127));
489 assert!(!fb.contains(128));
490 }
491
492 #[test]
493 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
contains_all_in_range()494 fn contains_all_in_range() {
495 let mut fb = FixedBitSet::with_capacity(48);
496 fb.insert_range(..);
497
498 fb.remove_range(..32);
499 fb.remove_range(37..);
500
501 assert!(fb.contains_all_in_range(32..37));
502 assert!(fb.contains_all_in_range(32..35));
503 assert!(!fb.contains_all_in_range(32..));
504 assert!(!fb.contains_all_in_range(..37));
505 assert!(!fb.contains_all_in_range(..));
506 }
507
508 #[test]
509 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
contains_any_in_range()510 fn contains_any_in_range() {
511 let mut fb = FixedBitSet::with_capacity(48);
512 fb.insert_range(..);
513
514 fb.remove_range(..32);
515 fb.remove_range(37..);
516
517 assert!(!fb.contains_any_in_range(..32));
518 assert!(fb.contains_any_in_range(32..37));
519 assert!(fb.contains_any_in_range(32..35));
520 assert!(fb.contains_any_in_range(32..));
521 assert!(fb.contains_any_in_range(..37));
522 assert!(!fb.contains_any_in_range(37..));
523 assert!(fb.contains_any_in_range(..));
524 }
525
526 #[test]
527 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
remove_range()528 fn remove_range() {
529 let mut fb = FixedBitSet::with_capacity(48);
530 fb.insert_range(..);
531
532 fb.remove_range(..32);
533 fb.remove_range(37..);
534
535 for i in 0..48 {
536 assert_eq!(fb.contains(i), 32 <= i && i < 37);
537 }
538 }
539
540 #[test]
541 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
set_range()542 fn set_range() {
543 let mut fb = FixedBitSet::with_capacity(48);
544 fb.insert_range(..);
545
546 fb.set_range(..32, false);
547 fb.set_range(37.., false);
548 fb.set_range(5..9, true);
549 fb.set_range(40..40, true);
550
551 for i in 0..48 {
552 assert_eq!(fb.contains(i), 5 <= i && i < 9 || 32 <= i && i < 37);
553 }
554 assert!(!fb.contains(48));
555 assert!(!fb.contains(64));
556 }
557
558 #[test]
559 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
toggle_range()560 fn toggle_range() {
561 let mut fb = FixedBitSet::with_capacity(40);
562 fb.insert_range(..10);
563 fb.insert_range(34..38);
564
565 fb.toggle_range(5..12);
566 fb.toggle_range(30..);
567
568 for i in 0..40 {
569 assert_eq!(
570 fb.contains(i),
571 i < 5 || 10 <= i && i < 12 || 30 <= i && i < 34 || 38 <= i
572 );
573 }
574 assert!(!fb.contains(40));
575 assert!(!fb.contains(64));
576 }
577
578 #[test]
579 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
bitand_equal_lengths()580 fn bitand_equal_lengths() {
581 let len = 109;
582 let a_end = 59;
583 let b_start = 23;
584 let mut a = FixedBitSet::with_capacity(len);
585 let mut b = FixedBitSet::with_capacity(len);
586 a.set_range(..a_end, true);
587 b.set_range(b_start.., true);
588 let ab = &a & &b;
589 for i in 0..b_start {
590 assert!(!ab.contains(i));
591 }
592 for i in b_start..a_end {
593 assert!(ab.contains(i));
594 }
595 for i in a_end..len {
596 assert!(!ab.contains(i));
597 }
598 assert_eq!(a.len(), ab.len());
599 }
600
601 #[test]
602 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
bitand_first_smaller()603 fn bitand_first_smaller() {
604 let a_len = 113;
605 let b_len = 137;
606 let len = core::cmp::min(a_len, b_len);
607 let a_end = 97;
608 let b_start = 89;
609 let mut a = FixedBitSet::with_capacity(a_len);
610 let mut b = FixedBitSet::with_capacity(b_len);
611 a.set_range(..a_end, true);
612 b.set_range(b_start.., true);
613 let ab = &a & &b;
614 for i in 0..b_start {
615 assert!(!ab.contains(i));
616 }
617 for i in b_start..a_end {
618 assert!(ab.contains(i));
619 }
620 for i in a_end..len {
621 assert!(!ab.contains(i));
622 }
623 assert_eq!(a.len(), ab.len());
624 }
625
626 #[test]
627 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
bitand_first_larger()628 fn bitand_first_larger() {
629 let a_len = 173;
630 let b_len = 137;
631 let len = core::cmp::min(a_len, b_len);
632 let a_end = 107;
633 let b_start = 43;
634 let mut a = FixedBitSet::with_capacity(a_len);
635 let mut b = FixedBitSet::with_capacity(b_len);
636 a.set_range(..a_end, true);
637 b.set_range(b_start.., true);
638 let ab = &a & &b;
639 for i in 0..b_start {
640 assert!(!ab.contains(i));
641 }
642 for i in b_start..a_end {
643 assert!(ab.contains(i));
644 }
645 for i in a_end..len {
646 assert!(!ab.contains(i));
647 }
648 assert_eq!(b.len(), ab.len());
649 }
650
651 #[test]
652 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
intersection()653 fn intersection() {
654 let len = 109;
655 let a_end = 59;
656 let b_start = 23;
657 let mut a = FixedBitSet::with_capacity(len);
658 let mut b = FixedBitSet::with_capacity(len);
659 a.set_range(..a_end, true);
660 b.set_range(b_start.., true);
661 let count = a.intersection_count(&b);
662 let iterator_count = a.intersection(&b).count();
663 let mut ab = a.intersection(&b).collect::<FixedBitSet>();
664
665 for i in 0..b_start {
666 assert!(!ab.contains(i));
667 }
668 for i in b_start..a_end {
669 assert!(ab.contains(i));
670 }
671 for i in a_end..len {
672 assert!(!ab.contains(i));
673 }
674
675 a.intersect_with(&b);
676 // intersection + collect produces the same results but with a shorter length.
677 ab.grow(a.len());
678 assert_eq!(
679 ab, a,
680 "intersection and intersect_with produce the same results"
681 );
682 assert_eq!(
683 ab.count_ones(..),
684 count,
685 "intersection and intersection_count produce the same results"
686 );
687 assert_eq!(
688 count, iterator_count,
689 "intersection and intersection_count produce the same results"
690 );
691 }
692
693 #[test]
694 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
union()695 fn union() {
696 let a_len = 173;
697 let b_len = 137;
698 let a_start = 139;
699 let b_end = 107;
700 let mut a = FixedBitSet::with_capacity(a_len);
701 let mut b = FixedBitSet::with_capacity(b_len);
702 a.set_range(a_start.., true);
703 b.set_range(..b_end, true);
704 let count = a.union_count(&b);
705 let iterator_count = a.union(&b).count();
706 let ab = a.union(&b).collect::<FixedBitSet>();
707 for i in a_start..a_len {
708 assert!(ab.contains(i));
709 }
710 for i in 0..b_end {
711 assert!(ab.contains(i));
712 }
713 for i in b_end..a_start {
714 assert!(!ab.contains(i));
715 }
716
717 a.union_with(&b);
718 assert_eq!(ab, a, "union and union_with produce the same results");
719 assert_eq!(
720 count,
721 ab.count_ones(..),
722 "union and union_count produce the same results"
723 );
724 assert_eq!(
725 count, iterator_count,
726 "union and union_count produce the same results"
727 );
728 }
729
730 #[test]
731 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
difference()732 fn difference() {
733 let a_len = 83;
734 let b_len = 151;
735 let a_start = 0;
736 let a_end = 79;
737 let b_start = 53;
738 let mut a = FixedBitSet::with_capacity(a_len);
739 let mut b = FixedBitSet::with_capacity(b_len);
740 a.set_range(a_start..a_end, true);
741 b.set_range(b_start..b_len, true);
742 let count = a.difference_count(&b);
743 let iterator_count = a.difference(&b).count();
744 let mut a_diff_b = a.difference(&b).collect::<FixedBitSet>();
745 for i in a_start..b_start {
746 assert!(a_diff_b.contains(i));
747 }
748 for i in b_start..b_len {
749 assert!(!a_diff_b.contains(i));
750 }
751
752 a.difference_with(&b);
753 // difference + collect produces the same results but with a shorter length.
754 a_diff_b.grow(a.len());
755 assert_eq!(
756 a_diff_b, a,
757 "difference and difference_with produce the same results"
758 );
759 assert_eq!(
760 a_diff_b.count_ones(..),
761 count,
762 "difference and difference_count produce the same results"
763 );
764 assert_eq!(
765 count, iterator_count,
766 "intersection and intersection_count produce the same results"
767 );
768 }
769
770 #[test]
771 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
symmetric_difference()772 fn symmetric_difference() {
773 let a_len = 83;
774 let b_len = 151;
775 let a_start = 47;
776 let a_end = 79;
777 let b_start = 53;
778 let mut a = FixedBitSet::with_capacity(a_len);
779 let mut b = FixedBitSet::with_capacity(b_len);
780 a.set_range(a_start..a_end, true);
781 b.set_range(b_start..b_len, true);
782 let count = a.symmetric_difference_count(&b);
783 let iterator_count = a.symmetric_difference(&b).count();
784 let a_sym_diff_b = a.symmetric_difference(&b).collect::<FixedBitSet>();
785 for i in 0..a_start {
786 assert!(!a_sym_diff_b.contains(i));
787 }
788 for i in a_start..b_start {
789 assert!(a_sym_diff_b.contains(i));
790 }
791 for i in b_start..a_end {
792 assert!(!a_sym_diff_b.contains(i));
793 }
794 for i in a_end..b_len {
795 assert!(a_sym_diff_b.contains(i));
796 }
797
798 a.symmetric_difference_with(&b);
799 assert_eq!(
800 a_sym_diff_b, a,
801 "symmetric_difference and _with produce the same results"
802 );
803 assert_eq!(
804 a_sym_diff_b.count_ones(..),
805 count,
806 "symmetric_difference and _count produce the same results"
807 );
808 assert_eq!(
809 count, iterator_count,
810 "symmetric_difference and _count produce the same results"
811 );
812 }
813
814 #[test]
815 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
bitor_equal_lengths()816 fn bitor_equal_lengths() {
817 let len = 109;
818 let a_start = 17;
819 let a_end = 23;
820 let b_start = 19;
821 let b_end = 59;
822 let mut a = FixedBitSet::with_capacity(len);
823 let mut b = FixedBitSet::with_capacity(len);
824 a.set_range(a_start..a_end, true);
825 b.set_range(b_start..b_end, true);
826 let ab = &a | &b;
827 for i in 0..a_start {
828 assert!(!ab.contains(i));
829 }
830 for i in a_start..b_end {
831 assert!(ab.contains(i));
832 }
833 for i in b_end..len {
834 assert!(!ab.contains(i));
835 }
836 assert_eq!(ab.len(), len);
837 }
838
839 #[test]
840 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
bitor_first_smaller()841 fn bitor_first_smaller() {
842 let a_len = 113;
843 let b_len = 137;
844 let a_end = 89;
845 let b_start = 97;
846 let mut a = FixedBitSet::with_capacity(a_len);
847 let mut b = FixedBitSet::with_capacity(b_len);
848 a.set_range(..a_end, true);
849 b.set_range(b_start.., true);
850 let ab = &a | &b;
851 for i in 0..a_end {
852 assert!(ab.contains(i));
853 }
854 for i in a_end..b_start {
855 assert!(!ab.contains(i));
856 }
857 for i in b_start..b_len {
858 assert!(ab.contains(i));
859 }
860 assert_eq!(b_len, ab.len());
861 }
862
863 #[test]
864 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
bitor_first_larger()865 fn bitor_first_larger() {
866 let a_len = 173;
867 let b_len = 137;
868 let a_start = 139;
869 let b_end = 107;
870 let mut a = FixedBitSet::with_capacity(a_len);
871 let mut b = FixedBitSet::with_capacity(b_len);
872 a.set_range(a_start.., true);
873 b.set_range(..b_end, true);
874 let ab = &a | &b;
875 for i in a_start..a_len {
876 assert!(ab.contains(i));
877 }
878 for i in 0..b_end {
879 assert!(ab.contains(i));
880 }
881 for i in b_end..a_start {
882 assert!(!ab.contains(i));
883 }
884 assert_eq!(a_len, ab.len());
885 }
886
887 #[test]
888 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
bitxor_equal_lengths()889 fn bitxor_equal_lengths() {
890 let len = 109;
891 let a_end = 59;
892 let b_start = 23;
893 let mut a = FixedBitSet::with_capacity(len);
894 let mut b = FixedBitSet::with_capacity(len);
895 a.set_range(..a_end, true);
896 b.set_range(b_start.., true);
897 let ab = &a ^ &b;
898 for i in 0..b_start {
899 assert!(ab.contains(i));
900 }
901 for i in b_start..a_end {
902 assert!(!ab.contains(i));
903 }
904 for i in a_end..len {
905 assert!(ab.contains(i));
906 }
907 assert_eq!(a.len(), ab.len());
908 }
909
910 #[test]
911 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
bitxor_first_smaller()912 fn bitxor_first_smaller() {
913 let a_len = 113;
914 let b_len = 137;
915 let len = core::cmp::max(a_len, b_len);
916 let a_end = 97;
917 let b_start = 89;
918 let mut a = FixedBitSet::with_capacity(a_len);
919 let mut b = FixedBitSet::with_capacity(b_len);
920 a.set_range(..a_end, true);
921 b.set_range(b_start.., true);
922 let ab = &a ^ &b;
923 for i in 0..b_start {
924 assert!(ab.contains(i));
925 }
926 for i in b_start..a_end {
927 assert!(!ab.contains(i));
928 }
929 for i in a_end..len {
930 assert!(ab.contains(i));
931 }
932 assert_eq!(b.len(), ab.len());
933 }
934
935 #[test]
936 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
bitxor_first_larger()937 fn bitxor_first_larger() {
938 let a_len = 173;
939 let b_len = 137;
940 let len = core::cmp::max(a_len, b_len);
941 let a_end = 107;
942 let b_start = 43;
943 let mut a = FixedBitSet::with_capacity(a_len);
944 let mut b = FixedBitSet::with_capacity(b_len);
945 a.set_range(..a_end, true);
946 b.set_range(b_start.., true);
947 let ab = &a ^ &b;
948 for i in 0..b_start {
949 assert!(ab.contains(i));
950 }
951 for i in b_start..a_end {
952 assert!(!ab.contains(i));
953 }
954 for i in a_end..b_len {
955 assert!(ab.contains(i));
956 }
957 for i in b_len..len {
958 assert!(!ab.contains(i));
959 }
960 assert_eq!(a.len(), ab.len());
961 }
962
963 #[test]
964 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
bitand_assign_shorter()965 fn bitand_assign_shorter() {
966 let a_ones: Vec<usize> = vec![2, 3, 7, 19, 31, 32, 37, 41, 43, 47, 71, 73, 101];
967 let b_ones: Vec<usize> = vec![2, 7, 8, 11, 23, 31, 32];
968 let a_and_b: Vec<usize> = vec![2, 7, 31, 32];
969 let mut a = a_ones.iter().cloned().collect::<FixedBitSet>();
970 let b = b_ones.iter().cloned().collect::<FixedBitSet>();
971 a &= b;
972 let res = a.ones().collect::<Vec<usize>>();
973
974 assert!(res == a_and_b);
975 }
976
977 #[test]
978 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
bitand_assign_longer()979 fn bitand_assign_longer() {
980 let a_ones: Vec<usize> = vec![2, 7, 8, 11, 23, 31, 32];
981 let b_ones: Vec<usize> = vec![2, 3, 7, 19, 31, 32, 37, 41, 43, 47, 71, 73, 101];
982 let a_and_b: Vec<usize> = vec![2, 7, 31, 32];
983 let mut a = a_ones.iter().cloned().collect::<FixedBitSet>();
984 let b = b_ones.iter().cloned().collect::<FixedBitSet>();
985 a &= b;
986 let res = a.ones().collect::<Vec<usize>>();
987 assert!(res == a_and_b);
988 }
989
990 #[test]
991 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
bitor_assign_shorter()992 fn bitor_assign_shorter() {
993 let a_ones: Vec<usize> = vec![2, 3, 7, 19, 31, 32, 37, 41, 43, 47, 71, 73, 101];
994 let b_ones: Vec<usize> = vec![2, 7, 8, 11, 23, 31, 32];
995 let a_or_b: Vec<usize> = vec![2, 3, 7, 8, 11, 19, 23, 31, 32, 37, 41, 43, 47, 71, 73, 101];
996 let mut a = a_ones.iter().cloned().collect::<FixedBitSet>();
997 let b = b_ones.iter().cloned().collect::<FixedBitSet>();
998 a |= b;
999 let res = a.ones().collect::<Vec<usize>>();
1000 assert!(res == a_or_b);
1001 }
1002
1003 #[test]
1004 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
bitor_assign_longer()1005 fn bitor_assign_longer() {
1006 let a_ones: Vec<usize> = vec![2, 7, 8, 11, 23, 31, 32];
1007 let b_ones: Vec<usize> = vec![2, 3, 7, 19, 31, 32, 37, 41, 43, 47, 71, 73, 101];
1008 let a_or_b: Vec<usize> = vec![2, 3, 7, 8, 11, 19, 23, 31, 32, 37, 41, 43, 47, 71, 73, 101];
1009 let mut a = a_ones.iter().cloned().collect::<FixedBitSet>();
1010 let b = b_ones.iter().cloned().collect::<FixedBitSet>();
1011 a |= b;
1012 let res = a.ones().collect::<Vec<usize>>();
1013 assert_eq!(res, a_or_b);
1014 }
1015
1016 #[test]
1017 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
bitxor_assign_shorter()1018 fn bitxor_assign_shorter() {
1019 let a_ones: Vec<usize> = vec![2, 3, 7, 19, 31, 32, 37, 41, 43, 47, 71, 73, 101];
1020 let b_ones: Vec<usize> = vec![2, 7, 8, 11, 23, 31, 32];
1021 let a_xor_b: Vec<usize> = vec![3, 8, 11, 19, 23, 37, 41, 43, 47, 71, 73, 101];
1022 let mut a = a_ones.iter().cloned().collect::<FixedBitSet>();
1023 let b = b_ones.iter().cloned().collect::<FixedBitSet>();
1024 a ^= b;
1025 let res = a.ones().collect::<Vec<usize>>();
1026 assert!(res == a_xor_b);
1027 }
1028
1029 #[test]
1030 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
bitxor_assign_longer()1031 fn bitxor_assign_longer() {
1032 let a_ones: Vec<usize> = vec![2, 7, 8, 11, 23, 31, 32];
1033 let b_ones: Vec<usize> = vec![2, 3, 7, 19, 31, 32, 37, 41, 43, 47, 71, 73, 101];
1034 let a_xor_b: Vec<usize> = vec![3, 8, 11, 19, 23, 37, 41, 43, 47, 71, 73, 101];
1035 let mut a = a_ones.iter().cloned().collect::<FixedBitSet>();
1036 let b = b_ones.iter().cloned().collect::<FixedBitSet>();
1037 a ^= b;
1038 let res = a.ones().collect::<Vec<usize>>();
1039 assert!(res == a_xor_b);
1040 }
1041
1042 #[test]
1043 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
op_assign_ref()1044 fn op_assign_ref() {
1045 let mut a = FixedBitSet::with_capacity(8);
1046 let b = FixedBitSet::with_capacity(8);
1047
1048 //check that all assign type operators work on references
1049 a &= &b;
1050 a |= &b;
1051 a ^= &b;
1052 }
1053
1054 #[test]
1055 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
subset_superset_shorter()1056 fn subset_superset_shorter() {
1057 let a_ones: Vec<usize> = vec![7, 31, 32, 63];
1058 let b_ones: Vec<usize> = vec![2, 7, 19, 31, 32, 37, 41, 43, 47, 63, 73, 101];
1059 let mut a = a_ones.iter().cloned().collect::<FixedBitSet>();
1060 let b = b_ones.iter().cloned().collect::<FixedBitSet>();
1061 assert!(a.is_subset(&b) && b.is_superset(&a));
1062 a.insert(14);
1063 assert!(!a.is_subset(&b) && !b.is_superset(&a));
1064 }
1065
1066 #[test]
1067 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
subset_superset_longer()1068 fn subset_superset_longer() {
1069 let a_len = 153;
1070 let b_len = 75;
1071 let a_ones: Vec<usize> = vec![7, 31, 32, 63];
1072 let b_ones: Vec<usize> = vec![2, 7, 19, 31, 32, 37, 41, 43, 47, 63, 73];
1073 let mut a = FixedBitSet::with_capacity(a_len);
1074 let mut b = FixedBitSet::with_capacity(b_len);
1075 a.extend(a_ones.iter().cloned());
1076 b.extend(b_ones.iter().cloned());
1077 assert!(a.is_subset(&b) && b.is_superset(&a));
1078 a.insert(100);
1079 assert!(!a.is_subset(&b) && !b.is_superset(&a));
1080 }
1081
1082 #[test]
1083 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
is_disjoint_first_shorter()1084 fn is_disjoint_first_shorter() {
1085 let a_len = 75;
1086 let b_len = 153;
1087 let a_ones: Vec<usize> = vec![2, 19, 32, 37, 41, 43, 47, 73];
1088 let b_ones: Vec<usize> = vec![7, 23, 31, 63, 124];
1089 let mut a = FixedBitSet::with_capacity(a_len);
1090 let mut b = FixedBitSet::with_capacity(b_len);
1091 a.extend(a_ones.iter().cloned());
1092 b.extend(b_ones.iter().cloned());
1093 assert!(a.is_disjoint(&b));
1094 a.insert(63);
1095 assert!(!a.is_disjoint(&b));
1096 }
1097
1098 #[test]
1099 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
is_disjoint_first_longer()1100 fn is_disjoint_first_longer() {
1101 let a_ones: Vec<usize> = vec![2, 19, 32, 37, 41, 43, 47, 73, 101];
1102 let b_ones: Vec<usize> = vec![7, 23, 31, 63];
1103 let a = a_ones.iter().cloned().collect::<FixedBitSet>();
1104 let mut b = b_ones.iter().cloned().collect::<FixedBitSet>();
1105 assert!(a.is_disjoint(&b));
1106 b.insert(2);
1107 assert!(!a.is_disjoint(&b));
1108 }
1109
1110 #[test]
1111 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
extend_on_empty()1112 fn extend_on_empty() {
1113 let items: Vec<usize> = vec![2, 3, 5, 7, 11, 13, 17, 19, 23, 27, 29, 31, 37, 167];
1114 let mut fbs = FixedBitSet::with_capacity(0);
1115 fbs.extend(items.iter().cloned());
1116 let ones = fbs.ones().collect::<Vec<usize>>();
1117 assert!(ones == items);
1118 }
1119
1120 #[test]
1121 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
extend()1122 fn extend() {
1123 let items: Vec<usize> = vec![2, 3, 5, 7, 11, 13, 17, 19, 23, 27, 29, 31, 37, 167];
1124 let mut fbs = FixedBitSet::with_capacity(168);
1125 let new: Vec<usize> = vec![7, 37, 67, 137];
1126 for i in &new {
1127 fbs.put(*i);
1128 }
1129
1130 fbs.extend(items.iter().cloned());
1131
1132 let ones = fbs.ones().collect::<Vec<usize>>();
1133 let expected = {
1134 let mut tmp = items.clone();
1135 tmp.extend(new);
1136 tmp.sort();
1137 tmp.dedup();
1138 tmp
1139 };
1140
1141 assert_eq!(ones, expected);
1142 }
1143
1144 #[test]
1145 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
from_iterator()1146 fn from_iterator() {
1147 let items: Vec<usize> = vec![0, 2, 4, 6, 8];
1148 let fb = items.iter().cloned().collect::<FixedBitSet>();
1149 for i in items {
1150 assert!(fb.contains(i));
1151 }
1152 for i in vec![1, 3, 5, 7] {
1153 assert!(!fb.contains(i));
1154 }
1155 assert_eq!(fb.len(), 9);
1156 }
1157
1158 #[test]
1159 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
from_iterator_ones()1160 fn from_iterator_ones() {
1161 let len = 257;
1162 let mut fb = FixedBitSet::with_capacity(len);
1163 for i in (0..len).filter(|i| i % 7 == 0) {
1164 fb.put(i);
1165 }
1166 fb.put(len - 1);
1167 let dup = fb.ones().collect::<FixedBitSet>();
1168
1169 assert_eq!(fb.len(), dup.len());
1170 assert_eq!(
1171 fb.ones().collect::<Vec<usize>>(),
1172 dup.ones().collect::<Vec<usize>>()
1173 );
1174 }
1175
1176 #[test]
1177 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
zeroes()1178 fn zeroes() {
1179 let len = 232;
1180 let mut fb = FixedBitSet::with_capacity(len);
1181 for i in (0..len).filter(|i| i % 7 == 0) {
1182 fb.insert(i);
1183 }
1184 let zeroes = fb.zeroes().collect::<Vec<usize>>();
1185
1186 assert_eq!(
1187 zeroes,
1188 vec![
1189 1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 15, 16, 17, 18, 19, 20, 22, 23, 24, 25, 26, 27,
1190 29, 30, 31, 32, 33, 34, 36, 37, 38, 39, 40, 41, 43, 44, 45, 46, 47, 48, 50, 51, 52, 53,
1191 54, 55, 57, 58, 59, 60, 61, 62, 64, 65, 66, 67, 68, 69, 71, 72, 73, 74, 75, 76, 78, 79,
1192 80, 81, 82, 83, 85, 86, 87, 88, 89, 90, 92, 93, 94, 95, 96, 97, 99, 100, 101, 102, 103,
1193 104, 106, 107, 108, 109, 110, 111, 113, 114, 115, 116, 117, 118, 120, 121, 122, 123,
1194 124, 125, 127, 128, 129, 130, 131, 132, 134, 135, 136, 137, 138, 139, 141, 142, 143,
1195 144, 145, 146, 148, 149, 150, 151, 152, 153, 155, 156, 157, 158, 159, 160, 162, 163,
1196 164, 165, 166, 167, 169, 170, 171, 172, 173, 174, 176, 177, 178, 179, 180, 181, 183,
1197 184, 185, 186, 187, 188, 190, 191, 192, 193, 194, 195, 197, 198, 199, 200, 201, 202,
1198 204, 205, 206, 207, 208, 209, 211, 212, 213, 214, 215, 216, 218, 219, 220, 221, 222,
1199 223, 225, 226, 227, 228, 229, 230
1200 ]
1201 );
1202 }
1203
1204 #[cfg(feature = "std")]
1205 #[test]
1206 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
binary_trait()1207 fn binary_trait() {
1208 let items: Vec<usize> = vec![1, 5, 7, 10, 14, 15];
1209 let fb = items.iter().cloned().collect::<FixedBitSet>();
1210
1211 assert_eq!(alloc::format!("{:b}", fb), "0100010100100011");
1212 assert_eq!(alloc::format!("{:#b}", fb), "0b0100010100100011");
1213 }
1214
1215 #[cfg(feature = "std")]
1216 #[test]
1217 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
display_trait()1218 fn display_trait() {
1219 let len = 8;
1220 let mut fb = FixedBitSet::with_capacity(len);
1221
1222 fb.put(4);
1223 fb.put(2);
1224
1225 assert_eq!(alloc::format!("{}", fb), "00101000");
1226 assert_eq!(alloc::format!("{:#}", fb), "0b00101000");
1227 }
1228
1229 // TODO: Rewite this test to be platform agnostic.
1230 #[test]
1231 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
1232 #[cfg(all(feature = "serde", target_pointer_width = "64"))]
test_serialize()1233 fn test_serialize() {
1234 let mut fb = FixedBitSet::with_capacity(10);
1235 fb.put(2);
1236 fb.put(3);
1237 fb.put(6);
1238 fb.put(8);
1239 let serialized = serde_json::to_string(&fb).unwrap();
1240 assert_eq!(r#"{"length":10,"data":[76,1,0,0,0,0,0,0]}"#, serialized);
1241 }
1242
1243 #[test]
1244 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
test_is_clear()1245 fn test_is_clear() {
1246 let mut fb = FixedBitSet::with_capacity(0);
1247 assert!(fb.is_clear());
1248
1249 fb.grow(1);
1250 assert!(fb.is_clear());
1251
1252 fb.put(0);
1253 assert!(!fb.is_clear());
1254
1255 fb.grow(42);
1256 fb.clear();
1257 assert!(fb.is_clear());
1258
1259 fb.put(17);
1260 fb.put(19);
1261 assert!(!fb.is_clear());
1262 }
1263
1264 #[test]
1265 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
test_is_full()1266 fn test_is_full() {
1267 let mut fb = FixedBitSet::with_capacity(0);
1268 assert!(fb.is_full());
1269
1270 fb.grow(1);
1271 assert!(!fb.is_full());
1272
1273 fb.put(0);
1274 assert!(fb.is_full());
1275
1276 fb.grow(42);
1277 fb.clear();
1278 assert!(!fb.is_full());
1279
1280 fb.put(17);
1281 fb.put(19);
1282 assert!(!fb.is_full());
1283
1284 fb.insert_range(..);
1285 assert!(fb.is_full());
1286 }
1287
1288 #[test]
clone()1289 fn clone() {
1290 let mut fb = FixedBitSet::with_capacity(10000);
1291 fb.set(11, true);
1292 fb.set(12, true);
1293 fb.set(7, true);
1294 fb.set(35, true);
1295 fb.set(40, true);
1296 fb.set(77, true);
1297 fb.set(95, true);
1298 fb.set(50, true);
1299 fb.set(99, true);
1300
1301 let fb_clone = fb.clone();
1302 let mut fb_clone_from_smaller = FixedBitSet::with_capacity(1000000);
1303 let mut fb_clone_from_same = FixedBitSet::with_capacity(10000);
1304 let mut fb_clone_from_bigger = FixedBitSet::with_capacity(100);
1305 fb_clone_from_smaller.clone_from(&fb);
1306 fb_clone_from_same.clone_from(&fb);
1307 fb_clone_from_bigger.clone_from(&fb);
1308
1309 assert_eq!(&fb, &fb_clone);
1310 assert_eq!(&fb, &fb_clone_from_smaller);
1311 assert_eq!(&fb, &fb_clone_from_same);
1312 assert_eq!(&fb, &fb_clone_from_bigger);
1313 }
1314